Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Set a temperature limit on any machine sensor in Thresholds
probe372ff75e4e08
diff --git a/docs/release-control/v6/internal/subsystems/alerts.md b/docs/release-control/v6/internal/subsystems/alerts.mdindex a28f2de9d6..1bd248e31a 100644--- a/docs/release-control/v6/internal/subsystems/alerts.md+++ b/docs/release-control/v6/internal/subsystems/alerts.md@@ -1727,7 +1727,36 @@ the other host child alerts, still resolves under the child ID. Tests in`TestHostNativeSensorPendingRunRestartsAfterPolicyOff`,`TestHostNativeSensorUsesSensorDelayPolicy`) and`TestResourceAlertSpecValidateAllowsAgentSensorMigrationBridgeType` pin this.-No Thresholds UI writes these overrides yet.++Alerts → Thresholds → Machines writes these overrides in its Machine Sensors+section (`ThresholdsTableAgentSensorsSection`). It lists every usable+temperature sensor a machine reports, plus every sensor with saved settings,+so a configured sensor that reads invalid, has left the report, sits on a+machine that is not reporting, or belongs to a machine no longer present stays+editable and removable with its reason beside the name; a non-reporting+machine shows no current reading. Rows are grouped by the machine's resource+ID, not its name. The frontend builds the ID with `agentSensorResourceId`+(`frontend-modern/src/features/alerts/agentSensorIdentity.ts`), the same+UTF-8 hex encoding as `HostNativeSensorResourceID`, and the overrides+projection reads it back as type `agentSensor`. The section has no Global+Defaults row and no Alerts toggle: a row's presentation default is+`temperature: 0`, marked `presentationDefaults`, so an unconfigured sensor+reads Off as the engine treats it, and the limit cell is the only switch.+Because that default is display-only, saving any Off value on a sensor row+stores no threshold and removes an override left with nothing else, and any stored sensor override,+a saved 0 included, shows as Custom with a revert action. Other rows keep an+explicit Off over an Off inherited default, so it survives a later change to+that default. The overrides projection carries each stored override's note+for every resource type, so a reloaded editor keeps it. A row's delay action opens the alert intent editor on+`metric.temperature` (shared `getAlertResourcePreferredIntentSignal`), and+the editor keeps a target that is not a listed resource, such as a machine+sensor or disk, as its own option under the row's label instead of falling+back to the first listed resource; preview is unavailable for such targets.+A handoff is applied once per request: a later change to the resource list+does not replay it over the operator's own selection.+`useThresholdsHostData.agentSensors.test.ts`,+`useThresholdsOverrideMutations.test.tsx`, `AlertIntentPolicyPanel.test.tsx`+and `ResourceTable.test.tsx` pin the frontend side.### Agent custom sensors use canonical health-assessment alertsdiff --git a/docs/release-control/v6/internal/subsystems/api-contracts.md b/docs/release-control/v6/internal/subsystems/api-contracts.mdindex 2cc02cdc3d..15ba67a030 100644--- a/docs/release-control/v6/internal/subsystems/api-contracts.md+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md@@ -6405,9 +6405,13 @@ in `native`: `id` (`<chip>/<channel>`), `chip`, optional `adapter`, `channel`,`label`, `kind` (`temperature`/`fan`), `unit` (`celsius`/`rpm`), optional`value` and `status` (`ok`/`invalid`). The models-backed frontend hostsummary always emits `native` as a possibly empty array, beside `custom` and-`gpu`; the unified-resource and agent payloads omit it when empty. No-frontend code reads it yet, so `frontend-modern/src/types/api.ts` gains its-optional `native` type with the first consumer.+`gpu`; the unified-resource and agent payloads omit it when empty.+`frontend-modern/src/types/api.ts` mirrors it as optional+`HostSensorSummary.native: HostNativeSensor[]`, with `kind` and `unit` as the+literal unions above. Its first reader is the Alerts → Thresholds Machine+Sensors section, which lists only `temperature` entries, never shows an+`invalid` entry's value as a reading, and keeps a configured sensor whose+entry is missing as a retained row rather than a removal.`id` is the host-scoped sensor source key; `label` is display text and is notunique. Clients must not chart, alert on or headline an `invalid` entry, andmust not read an absent or empty `native` array, or an entry missing from adiff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 576ea2896d..fe5416e1e0 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -10392,6 +10392,23 @@ muted dash for metrics an override cannot store (Docker container restart andmemory-limit rules, every PMG threshold). No shared primitive, table componentor layout changes.+### Threshold rows hand a labelled target to the delay editor (1 November 2026)++A threshold row's delay action passes its resource ID, the alert signal from+the shared `getAlertResourcePreferredIntentSignal` (first supported CPU,+memory, disk or temperature column, else offline; desktop and mobile rows use+the same helper) and a label from `getAlertResourceIntentTargetLabel` (the+row's name and, when known, its machine or node). `AlertIntentPolicyPanel`+lists a target that is not one of its resources, such as a machine disk or+sensor child ID, as its own option under that label instead of resetting the+selection to the first listed resource, and disables preview for it. It+applies each handoff once, reading the resource list untracked, so an+inventory change cannot replay it over the operator's later selection. The+Machine Sensors section reuses the shared table with no Global Defaults row+and no Alerts column; its rows stay one line, with the reading and chip in the+subtitle and any `readingMessage` on the name's line. No shared primitive or+layout changes.+### Stopped VM filesystem presentation (12 October 2026)`getWorkloadGuestDiskRead` treats an explicitly stopped VM as having no currentdiff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex 4166077c47..6acce499e0 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -253,9 +253,10 @@ only still skips power collection, as before. The legacy maps keeptheir keys, filters and consumers. Cluster peer collection omits theinventory, which belongs to each host's own report.-This is the identity foundation for #3565. Nothing reads the inventory yet: it-adds no alert, threshold, History series, sensor preference, CPU-source choice-or UI. An absent field (older agent, failed collection), an empty inventory+This is the identity foundation for #3565. The alert engine reads it only for+temperature inputs with their own threshold, and Alerts → Thresholds lists it+in a Machine Sensors section to set that threshold (see the alerts contract);+it adds no History series, sensor preference, CPU-source choice or other UI. An absent field (older agent, failed collection), an empty inventoryand a truncated one are not distinguished, and the 256 bound drops the lastchips in name order, so no consumer may read a missing entry as a removedsensor until the report carries completeness state. When one chip's@@ -272,6 +273,19 @@ complete `Sensors` result, peer omission and ingest through the frontend andread-state projections. The fixtures are inferred lm-sensors JSON, not exportsfrom an installed host.+Mock Linux agent hosts carry a native inventory from `mockHostNativeSensors`+in `internal/mock/generator.go`: CPU core and two NVMe sensors whose labels+repeat across chips on every host, plus, on about one host in four (a stable+hash of the host ID), an Intel Mac's applesmc sensors with the battery+(`TB0T`), an implausible -127 °C reading that stays listed as `invalid`, and+a fan input. Values follow the host's existing temperature sample with fixed+offsets and refresh with the host's CPU sensors in the ordinary host update+(`updateHosts`, when random metrics are on), so mock mode exercises+the Thresholds sensor section and native sensor alerts with the same ID,+sort, status and kind rules as ingest.+`TestMockHostNativeSensorsMatchIngestedInventoryShape` and+`TestUpdateHostsRefreshesNativeSensorInventory` pin the shape and refresh.+### Background backup scans belong to their configured connectionPVE tasks, storage backups and guest snapshots share one in-flight owner perdiff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex 4df69320e7..d3b537a07b 100644--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md@@ -452,6 +452,14 @@ reading takes one `SampleMetric` and rebuilds its core list (copied, nevermutated in place), and each agent host rewrites its CPU keys from the sampleit already took. No new timer, pass or fixture-wide scan is added.+Mock Linux agent hosts rebuild their native sensor inventory (at most ten+entries) in that same per-host update in `updateHosts`, from one more+`SampleMetric` and a stable hash, only when the host already has one. That is constant work per+host per tick; it adds no timer, pass or fixture-wide scan, and the Thresholds+sensor rows are derived in the existing host-data memo, which parses+configured sensor IDs once into a per-host map, so composition is linear in+reported plus configured sensors.+### Unavailable filesystem values share the existing disk modelThe filesystem list and guest Overview use the same nullable measured-byte ratiodiff --git a/frontend-modern/browser-verification/1eb7f5ad6cfc79d0.json b/frontend-modern/browser-verification/1eb7f5ad6cfc79d0.jsonnew file mode 100644index 0000000000..4dcda3ed28--- /dev/null+++ b/frontend-modern/browser-verification/1eb7f5ad6cfc79d0.json@@ -0,0 +1,86 @@+{+ "version": 1,+ "base_sha": "faffec9441a10140bff1e9b8cc82a545155e4994",+ "verified_at": "2026-11-01T11:12:00Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsx",+ "frontend-modern/src/components/Alerts/AlertResourceTableRow.tsx",+ "frontend-modern/src/components/Alerts/ResourceTable.tsx",+ "frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.ts",+ "frontend-modern/src/components/Alerts/ThresholdsTableAgentSensorsSection.tsx",+ "frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsx",+ "frontend-modern/src/components/Alerts/alertResourceTableModel.ts",+ "frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsx",+ "frontend-modern/src/features/alerts/agentSensorIdentity.ts",+ "frontend-modern/src/features/alerts/alertOverridesModel.ts",+ "frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsx",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.ts",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.ts",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.ts",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.ts",+ "frontend-modern/src/features/alerts/thresholds/tableTypes.ts",+ "frontend-modern/src/features/alerts/thresholds/types.ts",+ "frontend-modern/src/features/alerts/types.ts",+ "frontend-modern/src/types/api.ts",+ "frontend-modern/src/utils/alertThresholdsPresentation.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsx": "26d9121cf18a62da503fbf45fed24190072565ee00e0f9421a88db3e43faa2ab",+ "frontend-modern/src/components/Alerts/AlertResourceTableRow.tsx": "82db0d7076c0452cdbafccee3bb3897d4bd49968199415d8b8feec8cfca06e99",+ "frontend-modern/src/components/Alerts/ResourceTable.tsx": "c55572fe61c417cc5be639559c7d10eb0bf53e3941905d47dc992cb54f5d84df",+ "frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.ts": "fe702e7fd6a25512b42be2b6dac833cda884de006d80dc3305fd9b9c395d05ea",+ "frontend-modern/src/components/Alerts/ThresholdsTableAgentSensorsSection.tsx": "14b6c8449f8c9bbe5667c694111a7d96b3a13afe5563449823ee6fde439c3945",+ "frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsx": "9086f095a9fc8f086bc2603acdf0e7ef8988769ba8456e81a26a4ec64948b54d",+ "frontend-modern/src/components/Alerts/alertResourceTableModel.ts": "c4cb57d1a935c48a7ff9569dca0db73f5ca8dbb198fda9686173b189a436b876",+ "frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsx": "442a8a7b0146aef22c77eb25de722299b7d842967a761641232bccc3a2fcd4b8",+ "frontend-modern/src/features/alerts/agentSensorIdentity.ts": "be2138170040c3437a082ac9d6540ffd8470b9f0de12b290670f7116ce51787c",+ "frontend-modern/src/features/alerts/alertOverridesModel.ts": "bc1d4f7db9e11eba3499876a7a454d54a7bd6b9d3efe70f9f6c7844d2f5191ac",+ "frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsx": "7dff533a9061298e696730e73a9f01861fc059d07a163ce61dd839dff62f0994",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.ts": "8eaf13cb4acf3042836f9f23595c63d4888f9572e445eef47b6269bb8e0f958d",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.ts": "1d70f2fa4b54c463ff04015cb912617f99075ed705b4cb618b517370be800516",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.ts": "677e6268fafbc87e8953cb26e7d2d38dbee848f1aa3cea4045d5f56582388367",+ "frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.ts": "f3b70db9ba7d82e782a8937d860d7d4c999436e99badad462dcee43873c7769b",+ "frontend-modern/src/features/alerts/thresholds/tableTypes.ts": "3234b55df9b465d3dbb64501e00a2d95897d026e018bf77ca4d7b08bb50a9708",+ "frontend-modern/src/features/alerts/thresholds/types.ts": "94ad016ffb13bbc502558d8a53b47786975511250c22388f6f762cc068fa6852",+ "frontend-modern/src/features/alerts/types.ts": "33d85b25ad07a723894314d4e17808c69b106544d15d1a6372274d267c86ba25",+ "frontend-modern/src/types/api.ts": "44ac592b94964945639fa62ade84314ca71f9914dcc8765d95242a19be1aa67c",+ "frontend-modern/src/utils/alertThresholdsPresentation.ts": "5317a78f48b29eae211d3f4ed515f633666c017afe0481e593fcd4ef4ec49fe7"+ },+ "routes": [+ "/alerts/thresholds/systems",+ "/alerts/thresholds/proxmox",+ "/alerts/overview"+ ],+ "viewports": [+ {+ "width": 1366,+ "height": 900+ },+ {+ "width": 375,+ "height": 812+ }+ ],+ "states": [+ "Machines tab collapsed: Machine Sensors group after Machine Disks with count 23 and the line \"Off until a sensor has its own limit\"",+ "Machine Sensors expanded on a private mock stack: rows grouped per machine, each one line with label, current reading and chip; every unconfigured sensor reads Off; no Global Defaults row and no Alerts column",+ "Intel Mac mock host (Meridian-731) lists TB0T, TC0P and Th1H; the invalid TB1T and the fan input are not listed",+ "Two NVMe drives labelled Composite on different chips read as two rows told apart by chip in the subtitle",+ "TB0T with a saved 15\u00b0C limit: Custom badge and revert action; limit and its note survive a page reload and reappear in the reopened editor",+ "Backend raised Meridian-731 (TB0T) temperature warning at 18.6\u00b0C against the 15\u00b0C limit; Alerts Overview shows it with alert and clear levels",+ "TB0T switched Off with the note cleared: row reads Off with no Custom badge, the saved config has no sensor override and the backend resolved the alert",+ "Delay editor opened from the TB0T row (desktop and phone) selects \"TB0T \u00b7 Meridian-731\" and Temperature threshold with preview disabled; a saved grace shows Remove override",+ "Phone width: sensor cards show name, reading and chip, the limit and edit, delay and revert actions"+ ],+ "interactions": [+ "Collapse all, then expand Machine Sensors",+ "Edit TB0T: switch the limit On, type 15, commit by clicking away, Save Changes; captured request stores agent:host-linux-4/sensor:<hex of applesmc-isa-0300/temp1> with trigger 15 and clear 10",+ "Edit TB0T again: add the note \"Battery: alert early\", save; captured request carries the note; reload and reopen the editor to find it",+ "Edit TB0T: clear the note, switch the limit Off, save; captured request has no sensor override",+ "Open the TB0T delay action, enter a 600 second grace and Save override; backend intent policy holds metric.temperature graceSeconds 600 for the sensor ID",+ "Open the TB0T delay action from the phone card",+ "Open Alerts Overview and find the TB0T alert card",+ "Switch between 1366x900 and 375x812 viewports"+ ]+}diff --git a/frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsx b/frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsxindex 72a6bac84c..bc6cd77673 100644--- a/frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsx+++ b/frontend-modern/src/components/Alerts/AlertResourceTableMobile.tsx@@ -29,6 +29,8 @@ import {getAlertResourceMetricDisplayValue,getAlertResourceRelaxedTriggerSummary,isAlertResourceMetricOverridden,+ getAlertResourceIntentTargetLabel,+ getAlertResourcePreferredIntentSignal,normalizeAlertResourceMetricKey,} from './alertResourceTableModel';import type { Resource } from '@/features/alerts/thresholds/tableTypes';@@ -392,18 +394,13 @@ export function AlertResourceTableMobile(props: AlertResourceTableMobileProps) {</Show><Show when={!isEditing() && props.table.onConfigureResourceIntent}><ActionIconButton- onClick={() => {- const preferredMetric = ['cpu', 'memory', 'disk'].find(- (metric) =>- props.table.columns.some(- (column) => normalizeAlertResourceMetricKey(column) === metric,- ) && alertResourceSupportsMetric(resource.type, metric),- );+ onClick={() =>props.table.onConfigureResourceIntent?.(resource.id,- preferredMetric ? `metric.${preferredMetric}` : 'state.offline',- );- }}+ getAlertResourcePreferredIntentSignal(props.table.columns, resource.type),+ getAlertResourceIntentTargetLabel(resource),+ )+ }label={`Configure alert delay for ${getAlertResourceLabel(resource)}`}title="Configure individual alert delay"tone="neutral"diff --git a/frontend-modern/src/components/Alerts/AlertResourceTableRow.tsx b/frontend-modern/src/components/Alerts/AlertResourceTableRow.tsxindex 6056c6a950..f8f10400ff 100644--- a/frontend-modern/src/components/Alerts/AlertResourceTableRow.tsx+++ b/frontend-modern/src/components/Alerts/AlertResourceTableRow.tsx@@ -26,8 +26,10 @@ import {getAlertResourceColumnKind,getAlertResourceLabel,getAlertResourceInitialEditMetric,+ getAlertResourceIntentTargetLabel,getAlertResourceMetricBounds,getAlertResourceMetricDisplayValue,+ getAlertResourcePreferredIntentSignal,getAlertResourceRelaxedTriggerSummary,isAlertResourceMetricOff,isAlertResourceMetricOverridden,@@ -68,7 +70,11 @@ interface AlertResourceTableRowProps {onSetOfflineState?: (resourceId: string, state: OfflineState) => void;onToggleBackup?: (resourceId: string, forceState?: boolean) => void;onToggleSnapshot?: (resourceId: string, forceState?: boolean) => void;- onConfigureResourceIntent?: (resourceId: string, signal: AlertIntentSignal) => void;+ onConfigureResourceIntent?: (+ resourceId: string,+ signal: AlertIntentSignal,+ label?: string,+ ) => void;globalDisableFlag?: () => boolean;globalDisableOfflineFlag?: () => boolean;editingNote: () => string;@@ -102,17 +108,8 @@ export function AlertResourceTableRow(props: AlertResourceTableRowProps) {props.editingThresholds(),isEditing(),);- const preferredIntentSignal = (): AlertIntentSignal => {- for (const metric of ['cpu', 'memory', 'disk'] as const) {- if (- props.columns.some((column) => normalizeAlertResourceMetricKey(column) === metric) &&- alertResourceSupportsMetric(props.resource.type, metric)- ) {- return `metric.${metric}`;- }- }- return 'state.offline';- };+ const preferredIntentSignal = (): AlertIntentSignal =>+ getAlertResourcePreferredIntentSignal(props.columns, props.resource.type);const getThresholds = (): AlertResourceThresholdMap => thresholds();@@ -649,6 +646,7 @@ export function AlertResourceTableRow(props: AlertResourceTableRowProps) {props.onConfigureResourceIntent?.(props.resource.id,preferredIntentSignal(),+ getAlertResourceIntentTargetLabel(props.resource),)}label={`Configure alert delay for ${resourceLabel()}`}diff --git a/frontend-modern/src/components/Alerts/ResourceTable.test.tsx b/frontend-modern/src/components/Alerts/ResourceTable.test.tsxindex ba45b50501..b0b2ab2638 100644--- a/frontend-modern/src/components/Alerts/ResourceTable.test.tsx+++ b/frontend-modern/src/components/Alerts/ResourceTable.test.tsx@@ -2369,7 +2369,7 @@ describe('ResourceTable', () => {fireEvent.click(screen.getByLabelText('Configure alert delay for Database VM'));- expect(onConfigureResourceIntent).toHaveBeenCalledWith('vm-1', 'metric.cpu');+ expect(onConfigureResourceIntent).toHaveBeenCalledWith('vm-1', 'metric.cpu', 'Database VM');});it('falls back to the offline signal when the row has no supported metric', () => {@@ -2383,7 +2383,38 @@ describe('ResourceTable', () => {fireEvent.click(screen.getByLabelText('Configure alert delay for Docker Host'));- expect(onConfigureResourceIntent).toHaveBeenCalledWith('docker-host-1', 'state.offline');+ expect(onConfigureResourceIntent).toHaveBeenCalledWith(+ 'docker-host-1',+ 'state.offline',+ 'Docker Host',+ );+ });++ it('opens a machine sensor on its temperature signal, named with its machine', () => {+ const onConfigureResourceIntent = vi.fn();+ const props = makeProps({+ resources: [+ makeResource({+ id: 'agent:host-1/sensor:6162',+ name: 'TB0T',+ type: 'agentSensor',+ node: 'macbook-pve',+ thresholds: {},+ defaults: { temperature: 0 },+ }),+ ],+ columns: ['Temp °C'],+ onConfigureResourceIntent,+ });+ render(() => <ResourceTable {...props} />);++ fireEvent.click(screen.getByLabelText('Configure alert delay for TB0T'));++ expect(onConfigureResourceIntent).toHaveBeenCalledWith(+ 'agent:host-1/sensor:6162',+ 'metric.temperature',+ 'TB0T · macbook-pve',+ );});it('shows delay toggle button when showDelayColumn and onMetricDelayChange are provided', () => {diff --git a/frontend-modern/src/components/Alerts/ResourceTable.tsx b/frontend-modern/src/components/Alerts/ResourceTable.tsxindex 8c28c22336..4e70819580 100644--- a/frontend-modern/src/components/Alerts/ResourceTable.tsx+++ b/frontend-modern/src/components/Alerts/ResourceTable.tsx@@ -19,7 +19,11 @@ export type { GroupHeaderMeta, Resource } from '@/features/alerts/thresholds/tabexport interface ResourceTableProps {title: string;- onConfigureResourceIntent?: (resourceId: string, signal: AlertIntentSignal) => void;+ onConfigureResourceIntent?: (+ resourceId: string,+ signal: AlertIntentSignal,+ label?: string,+ ) => void;resources?: Resource[];groupedResources?: Record<string, Resource[]>;columns: string[];diff --git a/frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.ts b/frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.tsindex 9ddb7bc4a5..4cb15349ea 100644--- a/frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.ts+++ b/frontend-modern/src/components/Alerts/Thresholds/hooks/useCollapsedSections.ts@@ -30,6 +30,7 @@ const DEFAULT_COLLAPSED: CollapsedSectionsState = {pmg: true,agents: true,agentDisks: true,+ agentSensors: true,dockerHosts: true,dockerContainers: true,kubernetesClusters: true,diff --git a/frontend-modern/src/components/Alerts/ThresholdsTableAgentSensorsSection.tsx b/frontend-modern/src/components/Alerts/ThresholdsTableAgentSensorsSection.tsxnew file mode 100644index 0000000000..1c5a196cbe--- /dev/null+++ b/frontend-modern/src/components/Alerts/ThresholdsTableAgentSensorsSection.tsx@@ -0,0 +1,64 @@+import { Show } from 'solid-js';+import Thermometer from 'lucide-solid/icons/thermometer';++import { ResourceTable } from './ResourceTable';+import { CollapsibleSection } from './Thresholds/sections/CollapsibleSection';+import { formatMetricValue } from '@/features/alerts/thresholds/helpers';+import type { ThresholdsTableSectionProps } from '@/features/alerts/thresholds/thresholdsTableSectionProps';++const AGENT_SENSOR_THRESHOLD_COLUMNS = ['Temp °C'];+const AGENT_SENSOR_COLUMN_TOOLTIPS = {+ 'Temp °C': 'Sensor temperature that raises an alert. Off until you set a limit.',+};++// Native lm-sensors temperatures, one row per sensor under its machine. A+// sensor alerts only on its own limit: there is no global default, so the+// section has no defaults row and every unconfigured sensor reads Off. The+// limit cell is the only switch, so there is no separate Alerts toggle.+export function ThresholdsTableAgentSensorsSection(props: ThresholdsTableSectionProps) {+ const { state, tableProps } = props;++ return (+ <Show when={state.hasSection('agentSensors')}>+ <CollapsibleSection+ id="agentSensors"+ title={state.sectionTitles.agentSensors}+ defaultsSummary="Off until a sensor has its own limit"+ resourceCount={state.agentSensorsWithOverrides().length}+ collapsed={state.isCollapsed('agentSensors')}+ onToggle={() => state.toggleSection('agentSensors')}+ icon={<Thermometer class="h-5 w-5" />}+ isGloballyDisabled={tableProps.disableAllAgents()}+ emptyMessage={state.AGENT_SENSORS_EMPTY_STATE}+ >+ <div ref={state.registerSection('agentSensors')} class="scroll-mt-24">+ <ResourceTable+ title=""+ onConfigureResourceIntent={tableProps.onConfigureResourceIntent}+ groupedResources={state.agentSensorsGroupedByAgent()}+ groupHeaderMeta={state.agentGroupHeaderMeta()}+ columns={AGENT_SENSOR_THRESHOLD_COLUMNS}+ columnTooltips={AGENT_SENSOR_COLUMN_TOOLTIPS}+ activeAlerts={tableProps.activeAlerts}+ emptyMessage={state.AGENT_SENSORS_FILTER_EMPTY_STATE}+ onEdit={state.startEditing}+ onSaveEdit={state.saveEdit}+ onCancelEdit={state.cancelEdit}+ onRemoveOverride={state.removeOverride}+ showAlertsColumn={false}+ showOfflineAlertsColumn={false}+ editingId={state.editingId}+ editingThresholds={state.editingThresholds}+ setEditingThresholds={state.setEditingThresholds}+ editingNote={state.editingNote}+ setEditingNote={state.setEditingNote}+ onBulkEdit={(ids) => state.handleBulkEdit(ids, AGENT_SENSOR_THRESHOLD_COLUMNS)}+ formatMetricValue={formatMetricValue}+ hasActiveAlert={state.hasActiveAlert}+ setHasUnsavedChanges={tableProps.setHasUnsavedChanges}+ />+ </div>+ </CollapsibleSection>+ </Show>+ );+}diff --git a/frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsx b/frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsxindex b860b18953..20fa2f8c86 100644--- a/frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsx+++ b/frontend-modern/src/components/Alerts/ThresholdsTableAgentsTab.tsx@@ -1,4 +1,5 @@import { ThresholdsTableAgentDisksSection } from './ThresholdsTableAgentDisksSection';+import { ThresholdsTableAgentSensorsSection } from './ThresholdsTableAgentSensorsSection';import { ThresholdsTableAgentsResourcesSection } from './ThresholdsTableAgentsResourcesSection';import { ThresholdsTableSMARTDefaultsCard } from './ThresholdsTableSMARTDefaultsCard';import type { ThresholdsTableSectionProps } from '@/features/alerts/thresholds/thresholdsTableSectionProps';@@ -9,6 +10,7 @@ export function ThresholdsTableAgentsTab(props: ThresholdsTableSectionProps) {{/* The groups and their default limits lead; disk health rules follow. */}<ThresholdsTableAgentsResourcesSection {...props} /><ThresholdsTableAgentDisksSection {...props} />+ <ThresholdsTableAgentSensorsSection {...props} /><ThresholdsTableSMARTDefaultsCard {...props} /></>);diff --git a/frontend-modern/src/components/Alerts/alertResourceTableModel.ts b/frontend-modern/src/components/Alerts/alertResourceTableModel.tsindex c07bffa712..caa7cf4ad2 100644--- a/frontend-modern/src/components/Alerts/alertResourceTableModel.ts+++ b/frontend-modern/src/components/Alerts/alertResourceTableModel.ts@@ -1,3 +1,4 @@+import type { AlertIntentSignal } from '@/api/alertIntentPolicies';import type { Resource as UnifiedResource, ResourcePolicy } from '@/types/resource';import type { PlatformTableColumnKind } from '@/features/platformPage/columnAlignment';import { getPreferredInfrastructureDisplayName } from '@/utils/resourceIdentity';@@ -330,6 +331,35 @@ export function getAlertResourceInitialEditMetric(columns: string[], resourceTyp);}+// The alert signal a row's delay action configures: its first threshold+// metric the resource supports, else its offline state.+export function getAlertResourcePreferredIntentSignal(+ columns: readonly string[],+ resourceType: string | undefined,+): AlertIntentSignal {+ for (const metric of ['cpu', 'memory', 'disk', 'temperature'] as const) {+ if (+ columns.some((column) => normalizeAlertResourceMetricKey(column) === metric) &&+ alertResourceSupportsMetric(resourceType, metric)+ ) {+ return `metric.${metric}`;+ }+ }+ return 'state.offline';+}++// How the delay panel names a row it may not list itself, such as a machine+// disk or sensor: the row's label and, when known, its machine or node.+export function getAlertResourceIntentTargetLabel(resource: {+ name: string;+ displayName?: string;+ node?: string;+}): string {+ const label = resource.displayName?.trim() || resource.name;+ const node = resource.node?.trim();+ return node && node !== label ? `${label} · ${node}` : label;+}+export function alertResourceSupportsMetric(resourceType: string | undefined,metric: string,@@ -347,6 +377,9 @@ export function alertResourceSupportsMetric(if (resourceType === 'storage') {return metric === 'usage';}+ if (resourceType === 'agentSensor') {+ return metric === 'temperature';+ }if (resourceType === 'kubernetesNamespace') {return false;}diff --git a/frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsx b/frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsxindex ef6e916db5..3dffe0156d 100644--- a/frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsx+++ b/frontend-modern/src/features/alerts/AlertIntentPolicyPanel.tsx@@ -1,4 +1,4 @@-import { For, Show, createEffect, createMemo, createSignal, onMount } from 'solid-js';+import { For, Show, createEffect, createMemo, createSignal, onMount, untrack } from 'solid-js';import {AlertIntentPoliciesAPI,@@ -27,6 +27,7 @@ const SIGNALS: ReadonlyArray<{ value: AlertIntentSignal; label: string }> = [{ value: 'metric.cpu', label: 'CPU threshold' },{ value: 'metric.memory', label: 'Memory threshold' },{ value: 'metric.disk', label: 'Disk threshold' },+ { value: 'metric.temperature', label: 'Temperature threshold' },];const MAX_GRACE_SECONDS = 30 * 24 * 60 * 60;@@ -63,9 +64,16 @@ const ruleFor = (export interface AlertIntentPolicySelectionTarget {resourceId: string;signal: AlertIntentSignal;+ /** Names a target the resource list does not hold, such as a machine sensor. */+ label?: string;requestId: number;}+interface AlertIntentResourceOption {+ id: string;+ label: string;+}+export function AlertIntentPolicyPanel(props: {resources: readonly Resource[];selectionTarget?: AlertIntentPolicySelectionTarget | null;@@ -93,6 +101,20 @@ export function AlertIntentPolicyPanel(props: {),),);+ // A row can target a child alert resource (a machine disk or sensor) that+ // is not itself a listed resource. It joins the options under the row's own+ // label rather than the selection falling back to an unrelated resource.+ const [targetOption, setTargetOption] = createSignal<AlertIntentResourceOption | null>(null);+ const resourceOptions = createMemo<AlertIntentResourceOption[]>(() => {+ const listed = sortedResources().map((resource) => ({+ id: resource.id,+ label: `${getPreferredInfrastructureDisplayName(resource)} · ${resource.type}`,+ }));+ const target = targetOption();+ return target && !listed.some((option) => option.id === target.id)+ ? [target, ...listed]+ : listed;+ });const [resourceId, setResourceId] = createSignal('');const [signal, setSignal] = createSignal<AlertIntentSignal>('state.offline');const [overrideGrace, setOverrideGrace] = createSignal('');@@ -130,8 +152,8 @@ export function AlertIntentPolicyPanel(props: {setBackupAware(offline.backupOffline?.enabled ?? false);setBackupPostGrace(String(offline.backupOffline?.postGraceSeconds ?? 60));setBackupMaxDeferral(String(offline.backupOffline?.maxDeferralSeconds ?? 3600));- if (!resourceId() && sortedResources().length > 0) {- setResourceId(sortedResources()[0].id);+ if (!resourceId() && resourceOptions().length > 0) {+ setResourceId(resourceOptions()[0].id);}} catch (cause) {setError(cause instanceof Error ? cause.message : 'Failed to load alert intent policies.');@@ -143,14 +165,14 @@ export function AlertIntentPolicyPanel(props: {onMount(() => void load());createEffect(() => {- const resources = sortedResources();+ const options = resourceOptions();const selected = resourceId();- if (resources.length === 0) {+ if (options.length === 0) {if (selected) setResourceId('');return;}- if (!resources.some((resource) => resource.id === selected)) {- setResourceId(resources[0].id);+ if (!options.some((option) => option.id === selected)) {+ setResourceId(options[0].id);}});@@ -158,6 +180,14 @@ export function AlertIntentPolicyPanel(props: {const target = props.selectionTarget;if (!target) return;const requestId = target.requestId;+ // Untracked: a later inventory change must not replay this handoff over+ // a selection the operator has changed since.+ const listed = untrack(() =>+ sortedResources().some((resource) => resource.id === target.resourceId),+ );+ setTargetOption(+ listed ? null : { id: target.resourceId, label: target.label?.trim() || target.resourceId },+ );setResourceId(target.resourceId);setSignal(target.signal);setExpanded(true);@@ -509,12 +539,8 @@ export function AlertIntentPolicyPanel(props: {onChange={(event) => setResourceId(event.currentTarget.value)}fieldClass="lg:col-span-2">- <For each={sortedResources()}>- {(resource) => (- <option value={resource.id}>- {getPreferredInfrastructureDisplayName(resource)} · {resource.type}- </option>- )}+ <For each={resourceOptions()}>+ {(option) => <option value={option.id}>{option.label}</option>}</For></FormSelect><FormSelect@@ -616,7 +642,12 @@ export function AlertIntentPolicyPanel(props: {<Buttonvariant="secondary"isLoading={previewing()}- disabled={!resourceId() || previewing()}+ disabled={!selectedResource() || previewing()}+ title={+ selectedResource()+ ? undefined+ : 'Preview is available for listed resources, not machine disks or sensors.'+ }onClick={() => void runPreview()}>Preview current policydiff --git a/frontend-modern/src/features/alerts/__tests__/AlertIntentPolicyPanel.test.tsx b/frontend-modern/src/features/alerts/__tests__/AlertIntentPolicyPanel.test.tsxindex 00f2b7b735..52fbb80bc0 100644--- a/frontend-modern/src/features/alerts/__tests__/AlertIntentPolicyPanel.test.tsx+++ b/frontend-modern/src/features/alerts/__tests__/AlertIntentPolicyPanel.test.tsx@@ -96,6 +96,61 @@ describe('AlertIntentPolicyPanel', () => {expect(screen.getByLabelText('Signal')).toHaveValue('metric.memory');});+ it('keeps a row-selected machine sensor that the resource list does not hold', async () => {+ const sensorId = 'agent:host-1/sensor:6170706c65736d632d6973612d303330302f74656d7031';+ render(() => (+ <AlertIntentPolicyPanel+ resources={[resource]}+ selectionTarget={{+ resourceId: sensorId,+ signal: 'metric.temperature',+ label: 'TB0T · macbook-pve',+ requestId: 1,+ }}+ />+ ));++ expect(await screen.findByRole('button', { name: 'Hide policies' })).toBeInTheDocument();+ const select = screen.getByLabelText('Resource');+ expect(select).toHaveValue(sensorId);+ expect(screen.getByRole('option', { name: 'TB0T · macbook-pve' })).toBeInTheDocument();+ expect(screen.getByLabelText('Signal')).toHaveValue('metric.temperature');+ expect(screen.getByRole('button', { name: 'Preview current policy' })).toBeDisabled();++ fireEvent.input(await screen.findByLabelText(/^Grace override \(seconds\)/), {+ target: { value: '600' },+ });+ fireEvent.click(screen.getByRole('button', { name: 'Save override' }));++ await waitFor(() => expect(AlertIntentPoliciesAPI.update).toHaveBeenCalledTimes(1));+ const saved = vi.mocked(AlertIntentPoliciesAPI.update).mock.calls[0][0];+ expect(saved.resources?.[sensorId]?.['metric.temperature']).toEqual({ graceSeconds: 600 });+ });++ it('does not replay a row handoff when the resource list changes', async () => {+ const sensorId = 'agent:host-1/sensor:6162';+ const [resources, setResources] = createSignal<Resource[]>([resource]);+ render(() => (+ <AlertIntentPolicyPanel+ resources={resources()}+ selectionTarget={{+ resourceId: sensorId,+ signal: 'metric.temperature',+ label: 'TB0T · macbook-pve',+ requestId: 1,+ }}+ />+ ));++ const select = await screen.findByLabelText('Resource');+ fireEvent.change(select, { target: { value: resource.id } });+ fireEvent.change(screen.getByLabelText('Signal'), { target: { value: 'metric.cpu' } });+ setResources([resource, { ...resource, id: 'vm-other', name: 'other', displayName: 'other' }]);++ await waitFor(() => expect(screen.getByLabelText('Resource')).toHaveValue(resource.id));+ expect(screen.getByLabelText('Signal')).toHaveValue('metric.cpu');+ });+it('saves field-level resource overrides without disabling inherited policy', async () => {render(() => <AlertIntentPolicyPanel resources={[resource]} />);diff --git a/frontend-modern/src/features/alerts/agentSensorIdentity.ts b/frontend-modern/src/features/alerts/agentSensorIdentity.tsnew file mode 100644index 0000000000..c786071078--- /dev/null+++ b/frontend-modern/src/features/alerts/agentSensorIdentity.ts@@ -0,0 +1,33 @@+const AGENT_SENSOR_RESOURCE_ID_PATTERN = /^agent:(.+)\/sensor:((?:[0-9a-f]{2})+)$/;++// The alert resource ID of one native sensor, as the backend builds it+// (internal/alerts/host_native_sensor.go HostNativeSensorResourceID):+// "agent:<host ID>/sensor:<lower-case hex of the sensor ID's UTF-8 bytes>".+// The hex form keeps sensor IDs that differ only by case or punctuation apart.+export const agentSensorResourceId = (hostId: string, sensorId: string): string => {+ const hex = Array.from(new TextEncoder().encode(sensorId), (byte) =>+ byte.toString(16).padStart(2, '0'),+ ).join('');+ return `agent:${hostId.trim() || 'unknown'}/sensor:${hex}`;+};++// The host ID and sensor ID an agentSensorResourceId encodes, or null when+// the ID is not a native sensor resource.+export const parseAgentSensorResourceId = (+ resourceId: string,+): { hostId: string; sensorId: string } | null => {+ const match = resourceId.match(AGENT_SENSOR_RESOURCE_ID_PATTERN);+ if (!match) return null;+ const bytes = new Uint8Array(match[2].length / 2);+ for (let index = 0; index < bytes.length; index += 1) {+ bytes[index] = parseInt(match[2].slice(index * 2, index * 2 + 2), 16);+ }+ try {+ return {+ hostId: match[1],+ sensorId: new TextDecoder('utf-8', { fatal: true }).decode(bytes),+ };+ } catch {+ return null;+ }+};diff --git a/frontend-modern/src/features/alerts/alertOverridesModel.ts b/frontend-modern/src/features/alerts/alertOverridesModel.tsindex f39cb23a6d..d1f68cb201 100644--- a/frontend-modern/src/features/alerts/alertOverridesModel.ts+++ b/frontend-modern/src/features/alerts/alertOverridesModel.ts@@ -4,6 +4,7 @@ import type { Resource } from '@/types/resource';import { getActionableAgentIdFromResource, isTrueNASSystemResource } from '@/utils/agentResources';import { isAppContainerDiscoveryResourceType } from '@/utils/discoveryTarget';+import { parseAgentSensorResourceId } from './agentSensorIdentity';import {extractTriggerValues,getAlertResourceDisplayLabel,@@ -313,7 +314,15 @@ export const buildProjectedOverrides = ({{ resource: Resource; type: Override['type']; resourceType: string }>();- const upsertProjectedOverride = (override: Override) => {+ // Every projection is keyed by its raw override key, so the stored note is+ // carried here once for all resource types. Without it a reloaded editor+ // opens with a blank note and the next save drops the stored one.+ const upsertProjectedOverride = (projected: Override) => {+ const storedNote = rawConfig[projected.id]?.note;+ const override =+ projected.note === undefined && typeof storedNote === 'string' && storedNote.trim()+ ? { ...projected, note: storedNote }+ : projected;const existingIndex = overrideIndexByID.get(override.id);if (existingIndex !== undefined) {overridesList[existingIndex] = override;@@ -588,6 +597,21 @@ export const buildProjectedOverrides = ({return;}+ const sensorKey = parseAgentSensorResourceId(key);+ if (sensorKey) {+ const agent = agentMap.get(sensorKey.hostId);+ upsertProjectedOverride({+ id: key,+ name: sensorKey.sensorId,+ type: 'agentSensor',+ resourceType: 'Machine Sensor',+ node: agent ? getAlertResourceDisplayLabel(agent) : sensorKey.hostId,+ disabled: thresholds.disabled || false,+ thresholds: extractTriggerValues(thresholds),+ });+ return;+ }+const diskMatch = key.match(/^agent:(.+)\/disk:(.+)$/);if (diskMatch) {const [, agentId, diskLabel] = diskMatch;diff --git a/frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsx b/frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsxindex 78421cddf3..bc17e22a4e 100644--- a/frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsx+++ b/frontend-modern/src/features/alerts/tabs/ThresholdsTab.tsx@@ -15,11 +15,16 @@ export function ThresholdsTab(props: ThresholdsTabProps) {createSignal<AlertIntentPolicySelectionTarget | null>(null);let intentSelectionRequest = 0;- const configureResourceIntent = (resourceId: string, signal: AlertIntentSignal) => {+ const configureResourceIntent = (+ resourceId: string,+ signal: AlertIntentSignal,+ label?: string,+ ) => {intentSelectionRequest += 1;setIntentSelectionTarget({resourceId,signal,+ label,requestId: intentSelectionRequest,});};diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsHostData.agentSensors.test.ts b/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsHostData.agentSensors.test.tsnew file mode 100644index 0000000000..282b416d7f--- /dev/null+++ b/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsHostData.agentSensors.test.ts@@ -0,0 +1,264 @@+import { createRoot, createSignal } from 'solid-js';+import { describe, expect, it } from 'vitest';++import { buildProjectedOverrides } from '@/features/alerts/alertOverridesModel';+import {+ agentSensorResourceId,+ parseAgentSensorResourceId,+} from '@/features/alerts/agentSensorIdentity';+import type { HostNativeSensor } from '@/types/api';+import type { Resource } from '@/types/resource';++import type { Override, ThresholdsTableProps } from '../../types';+import { useThresholdsHostData } from '../useThresholdsHostData';++const sensor = (+ chip: string,+ channel: string,+ label: string,+ value: number | undefined,+ status: HostNativeSensor['status'] = 'ok',+ kind: HostNativeSensor['kind'] = 'temperature',+): HostNativeSensor => ({+ id: `${chip}/${channel}`,+ chip,+ channel,+ label,+ kind,+ unit: kind === 'fan' ? 'rpm' : 'celsius',+ value,+ status,+});++const machine = (+ id: string,+ hostId: string,+ name: string,+ native: HostNativeSensor[],+ status: Resource['status'] = 'online',+): Resource =>+ ({+ id,+ name,+ displayName: name,+ type: 'agent',+ status,+ agent: { agentId: hostId, sensors: { native } },+ }) as unknown as Resource;++const sensorOverride = (hostId: string, sensorId: string, trigger: number): Override => ({+ id: agentSensorResourceId(hostId, sensorId),+ name: sensorId,+ type: 'agentSensor',+ thresholds: { temperature: trigger },+});++const sensorRows = (agents: Resource[], overrides: Override[] = [], search = '') =>+ createRoot((dispose) => {+ const [term] = createSignal(search);+ const data = useThresholdsHostData({+ props: {+ agents,+ overrides: () => overrides,+ agentDefaults: {},+ nodeDefaults: {},+ } as unknown as ThresholdsTableProps,+ editingId: () => null,+ searchTerm: term,+ });+ const rows = data.agentSensorsWithOverrides();+ const groups = data.agentSensorsGroupedByAgent();+ dispose();+ return { rows, groups };+ });++describe('agentSensorResourceId', () => {+ it('builds the backend alert resource ID from the UTF-8 hex of the sensor ID', () => {+ expect(agentSensorResourceId('host-1', 'applesmc-isa-0300/temp1')).toBe(+ 'agent:host-1/sensor:6170706c65736d632d6973612d303330302f74656d7031',+ );+ // Case-only differences stay distinct, as the backend keeps them.+ expect(agentSensorResourceId('host-1', 'chip/TEMP1')).not.toBe(+ agentSensorResourceId('host-1', 'chip/temp1'),+ );+ });++ it('round-trips through parseAgentSensorResourceId and rejects other IDs', () => {+ const id = agentSensorResourceId('host:1', 'nvme-pci-0100/temp1');+ expect(parseAgentSensorResourceId(id)).toEqual({+ hostId: 'host:1',+ sensorId: 'nvme-pci-0100/temp1',+ });+ expect(parseAgentSensorResourceId('agent:host-1/disk:root')).toBeNull();+ expect(parseAgentSensorResourceId('agent:host-1/sensor:abc')).toBeNull();+ expect(parseAgentSensorResourceId('agent:host-1/sensor:ff')).toBeNull();+ });+});++describe('useThresholdsHostData machine sensors', () => {+ it('lists usable temperature sensors under their machine, Off by default', () => {+ const mac = machine('agent-res-1', 'host-1', 'macbook-pve', [+ sensor('applesmc-isa-0300', 'temp1', 'TB0T', 31.5),+ sensor('applesmc-isa-0300', 'temp2', 'TB1T', -127, 'invalid'),+ sensor('applesmc-isa-0300', 'fan1', 'Left side', 1800, 'ok', 'fan'),+ ]);++ const { rows, groups } = sensorRows([mac]);++ expect(rows).toHaveLength(1);+ expect(rows[0]).toMatchObject({+ id: agentSensorResourceId('host-1', 'applesmc-isa-0300/temp1'),+ name: 'TB0T',+ rawName: 'applesmc-isa-0300/temp1',+ type: 'agentSensor',+ node: 'macbook-pve',+ instance: 'applesmc-isa-0300',+ subtitle: '31.5°C · applesmc-isa-0300',+ defaults: { temperature: 0 },+ thresholds: {},+ hasOverride: false,+ });+ expect(rows[0].readingMessage).toBeUndefined();+ expect(Object.keys(groups)).toEqual(['agent-res-1']);+ });++ it('keeps configured sensors that read invalid or went missing', () => {+ const mac = machine('agent-res-1', 'host-1', 'macbook-pve', [+ sensor('applesmc-isa-0300', 'temp2', 'TB1T', -127, 'invalid'),+ ]);++ const { rows } = sensorRows(+ [mac],+ [+ sensorOverride('host-1', 'applesmc-isa-0300/temp2', 45),+ sensorOverride('host-1', 'applesmc-isa-0300/temp9', 50),+ ],+ );++ const byName = new Map(rows.map((row) => [row.name, row]));+ expect(byName.get('TB1T')).toMatchObject({+ hasOverride: true,+ thresholds: { temperature: 45 },+ subtitle: 'applesmc-isa-0300',+ readingMessage: 'No valid reading from this sensor.',+ });+ expect(byName.get('applesmc-isa-0300/temp9')).toMatchObject({+ hasOverride: true,+ thresholds: { temperature: 50 },+ readingMessage: 'Not reported by this machine. Saved alert settings are retained.',+ });+ });++ it('keeps a saved zero limit removable and carries the override note', () => {+ const mac = machine('agent-res-1', 'host-1', 'macbook-pve', [+ sensor('applesmc-isa-0300', 'temp1', 'TB0T', 31.5),+ ]);+ const saved: Override = {+ ...sensorOverride('host-1', 'applesmc-isa-0300/temp1', 0),+ note: 'battery swelling watch',+ };++ const { rows } = sensorRows([mac], [saved]);++ expect(rows[0]).toMatchObject({+ hasOverride: true,+ presentationDefaults: true,+ note: 'battery swelling watch',+ thresholds: { temperature: 0 },+ });+ });++ it('shows no current reading for a machine that is not reporting', () => {+ const offline = machine(+ 'agent-res-1',+ 'host-1',+ 'macbook-pve',+ [sensor('applesmc-isa-0300', 'temp1', 'TB0T', 31.5)],+ 'offline',+ );++ const { rows } = sensorRows(+ [offline],+ [sensorOverride('host-1', 'applesmc-isa-0300/temp1', 45)],+ );++ expect(rows).toHaveLength(1);+ expect(rows[0].subtitle).toBe('applesmc-isa-0300');+ expect(rows[0].readingMessage).toBe(+ 'Machine is not reporting, so there is no current reading.',+ );+ });++ it('tells repeated labels apart and keeps same-named machines apart', () => {+ const first = machine('agent-res-1', 'host-1', 'pve', [+ sensor('nvme-pci-0100', 'temp1', 'Composite', 40),+ sensor('nvme-pci-0200', 'temp1', 'Composite', 42),+ sensor('acpitz-acpi-0', 'temp1', 'temp', 30),+ sensor('acpitz-acpi-0', 'temp2', 'temp', 31),+ ]);+ const second = machine('agent-res-2', 'host-2', 'pve', [+ sensor('coretemp-isa-0000', 'temp1', 'Package id 0', 50),+ ]);++ const { rows, groups } = sensorRows([first, second]);++ // Across chips the subtitle's chip tells the rows apart; within one chip+ // the channel joins the name.+ expect(groups['agent-res-1'].map((row) => [row.name, row.subtitle])).toEqual([+ ['Composite', '40.0°C · nvme-pci-0100'],+ ['Composite', '42.0°C · nvme-pci-0200'],+ ['temp (temp1)', '30.0°C · acpitz-acpi-0'],+ ['temp (temp2)', '31.0°C · acpitz-acpi-0'],+ ]);+ expect(groups['agent-res-2'].map((row) => row.name)).toEqual(['Package id 0']);+ expect(new Set(rows.map((row) => row.id)).size).toBe(5);+ });++ it('keeps an override whose machine is gone, and searches by sensor ID', () => {+ const { rows, groups } = sensorRows([], [sensorOverride('ghost', 'chip/temp1', 60)]);+ expect(rows).toHaveLength(1);+ expect(rows[0]).toMatchObject({+ name: 'chip/temp1',+ node: 'ghost',+ readingMessage: 'Machine not found. Saved alert settings are retained.',+ });+ expect(Object.keys(groups)).toEqual(['ghost']);++ const mac = machine('agent-res-1', 'host-1', 'macbook-pve', [+ sensor('applesmc-isa-0300', 'temp1', 'TB0T', 31.5),+ sensor('coretemp-isa-0000', 'temp1', 'Package id 0', 50),+ ]);+ expect(sensorRows([mac], [], 'applesmc').rows.map((row) => row.name)).toEqual(['TB0T']);+ });+});++describe('buildProjectedOverrides machine sensors', () => {+ it('projects a sensor override with its sensor ID and machine name', () => {+ const mac = machine('agent-res-1', 'host-1', 'macbook-pve', []);+ const id = agentSensorResourceId('host-1', 'applesmc-isa-0300/temp1');++ const projected = buildProjectedOverrides({+ rawConfig: { [id]: { temperature: { trigger: 45, clear: 40 }, note: 'battery' } },+ nodeResources: [],+ vmResources: [],+ containerResources: [],+ storageResources: [],+ agentResourceList: [mac],+ containerRuntimeResources: [],+ getChildren: () => [],+ pbsInstanceById: new Map(),+ allResources: [mac],+ } as unknown as Parameters<typeof buildProjectedOverrides>[0]);++ expect(projected).toEqual([+ expect.objectContaining({+ id,+ note: 'battery',+ name: 'applesmc-isa-0300/temp1',+ type: 'agentSensor',+ node: 'macbook-pve',+ thresholds: { temperature: 45 },+ }),+ ]);+ });+});diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsOverrideMutations.test.tsx b/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsOverrideMutations.test.tsxindex 36711fff29..0c7e9a5777 100644--- a/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsOverrideMutations.test.tsx+++ b/frontend-modern/src/features/alerts/thresholds/hooks/__tests__/useThresholdsOverrideMutations.test.tsx@@ -112,6 +112,116 @@ describe('useThresholdsOverrideMutations', () => {expect(cancelEdit).toHaveBeenCalledTimes(1);});+ it('saves a machine sensor limit and drops the override when it is switched Off', () => {+ const overrideSignal = createSignal<any[]>([]);+ const { props, rawOverridesConfig } = buildTableProps(overrideSignal);+ const [editingThresholds, setEditingThresholds] = createSignal<+ Record<string, number | undefined>+ >({ temperature: 45 });+ const [editingNote] = createSignal('');+ const [bulkEditIds] = createSignal<string[]>([]);+ const cancelEdit = vi.fn();+ const sensorId = 'agent:host-1/sensor:6170706c65736d632d6973612d303330302f74656d7031';+ const [sensorRow, setSensorRow] = createSignal<TableResource>({+ id: sensorId,+ name: 'TB0T',+ type: 'agentSensor',+ resourceType: 'Machine Sensor',+ node: 'macbook-pve',+ instance: 'applesmc-isa-0300',+ defaults: { temperature: 0 },+ presentationDefaults: true,+ thresholds: {},+ });++ const { result } = renderHook(() =>+ useThresholdsOverrideMutations({+ props,+ resources: {+ nodesWithOverrides: () => [],+ agentsWithOverrides: () => [],+ agentDisksWithOverrides: () => [],+ agentSensorsWithOverrides: () => [sensorRow()],+ dockerHostsWithOverrides: () => [],+ guestsFlat: () => [],+ dockerContainersFlat: () => [],+ pbsServersWithOverrides: () => [],+ pmgServersWithOverrides: () => [],+ storageWithOverrides: () => [],+ },+ editingThresholds,+ editingNote,+ bulkEditIds,+ cancelEdit,+ }),+ );++ result.saveEdit(sensorId);++ expect(overrideSignal[0]()).toEqual([+ expect.objectContaining({+ id: sensorId,+ type: 'agentSensor',+ thresholds: { temperature: 45 },+ }),+ ]);+ expect(rawOverridesConfig()).toEqual({+ [sensorId]: { temperature: { trigger: 45, clear: 40 } },+ });++ setSensorRow((row) => ({ ...row, hasOverride: true, thresholds: { temperature: 45 } }));+ setEditingThresholds({ temperature: -1 });+ result.saveEdit(sensorId);++ expect(overrideSignal[0]()).toEqual([]);+ expect(rawOverridesConfig()).toEqual({});+ });++ it('keeps an explicit Off over an Off inherited default on ordinary rows', () => {+ const overrideSignal = createSignal<any[]>([]);+ const { props, rawOverridesConfig } = buildTableProps(overrideSignal);+ const [editingThresholds] = createSignal<Record<string, number | undefined>>({ cpu: -1 });+ const [editingNote] = createSignal('');+ const [bulkEditIds] = createSignal<string[]>([]);+ const machine: TableResource = {+ id: 'host-1',+ name: 'pve',+ type: 'agent',+ resourceType: 'System',+ defaults: { cpu: 0 },+ thresholds: {},+ };++ const { result } = renderHook(() =>+ useThresholdsOverrideMutations({+ props,+ resources: {+ nodesWithOverrides: () => [],+ agentsWithOverrides: () => [machine],+ agentDisksWithOverrides: () => [],+ dockerHostsWithOverrides: () => [],+ guestsFlat: () => [],+ dockerContainersFlat: () => [],+ pbsServersWithOverrides: () => [],+ pmgServersWithOverrides: () => [],+ storageWithOverrides: () => [],+ },+ editingThresholds,+ editingNote,+ bulkEditIds,+ cancelEdit: vi.fn(),+ }),+ );++ result.saveEdit('host-1');++ // The default may be switched back on later; the machine's Off must stay.+ expect(overrideSignal[0]()).toEqual([+ expect.objectContaining({ id: 'host-1', thresholds: { cpu: -1 } }),+ ]);+ expect(Object.keys(rawOverridesConfig())).toEqual(['host-1']);+ });+it('bulk-saves guest filesystem thresholds under the stable override identity', () => {const overrideSignal = createSignal<any[]>([]);const { props, rawOverridesConfig } = buildTableProps(overrideSignal);diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.ts b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.tsindex 0c7df6c540..a092194695 100644--- a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.ts+++ b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsAvailabilityMutations.ts@@ -23,6 +23,7 @@ interface ThresholdsAvailabilityMutationResources {nodesWithOverrides: () => TableResource[];agentsWithOverrides: () => TableResource[];agentDisksWithOverrides: () => TableResource[];+ agentSensorsWithOverrides?: () => TableResource[];guestDisksWithOverrides?: () => TableResource[];dockerHostsWithOverrides: () => TableResource[];guestsFlat: () => TableResource[];@@ -76,6 +77,7 @@ export function useThresholdsAvailabilityMutations({...resources.pbsServersWithOverrides(),...resources.agentsWithOverrides(),...resources.agentDisksWithOverrides(),+ ...optionalResources(resources.agentSensorsWithOverrides),...optionalResources(resources.guestDisksWithOverrides),...optionalResources(resources.kubernetesClustersWithOverrides),...optionalResources(resources.kubernetesNodesWithOverrides),@@ -100,6 +102,7 @@ export function useThresholdsAvailabilityMutations({resource.type !== 'dockerContainer' &&resource.type !== 'agent' &&resource.type !== 'agentDisk' &&+ resource.type !== 'agentSensor' &&resource.type !== 'guestDisk' &&resource.type !== 'kubernetesCluster' &&resource.type !== 'kubernetesNode' &&diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.ts b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.tsindex 22810065a2..24f6d5696a 100644--- a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.ts+++ b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsHostData.ts@@ -1,6 +1,11 @@import { createMemo } from 'solid-js';+import {+ parseAgentSensorResourceId,+ agentSensorResourceId,+} from '@/features/alerts/agentSensorIdentity';import { getAlertResourceDisplayLabel } from '@/features/alerts/helpers';+import { formatTemperature } from '@/utils/temperature';import type { GroupHeaderMeta, Resource as TableResource } from '../tableTypes';import { ThresholdsDataInputs } from '../thresholdsResourceModel';@@ -277,6 +282,153 @@ export function useThresholdsHostData(inputs: ThresholdsDataInputs) {return grouped;});+ // One row per usable temperature sensor a machine reports, plus every sensor+ // that has saved alert settings, so a configured sensor stays editable and+ // removable while it reads invalid, has gone missing or its machine is+ // offline. Sensors have no global default: the presentation default of 0+ // makes an unconfigured row read Off, which is what the alert engine does.+ const agentSensorsWithOverrides = createMemo<TableResource[]>((prev = []) => {+ if (editingId()) {+ return prev;+ }++ const search = searchTerm().toLowerCase();+ const overridesMap = createOverridesMap(props.overrides());+ // Configured sensor IDs parsed once, by host, so each machine reads only+ // its own entries.+ const configuredSensorIdsByHost = new Map<string, string[]>();+ (props.overrides() ?? []).forEach((override) => {+ if (override.type !== 'agentSensor') return;+ const parsed = parseAgentSensorResourceId(override.id);+ if (!parsed) return;+ const ids = configuredSensorIdsByHost.get(parsed.hostId) ?? [];+ ids.push(parsed.sensorId);+ configuredSensorIdsByHost.set(parsed.hostId, ids);+ });+ const seen = new Set<string>();+ const sensors: TableResource[] = [];++ (props.agents ?? []).forEach((agentResource) => {+ const hostId = readString(agentResource.agent?.agentId) || hostActionId(agentResource);+ const agentDisplayName = getAlertResourceDisplayLabel(agentResource);+ const hostReporting =+ agentResource.status !== 'offline' && agentResource.agent?.stale !== true;+ const reported = (agentResource.agent?.sensors?.native ?? []).filter(+ (sensor) => sensor.kind === 'temperature',+ );+ const reportedById = new Map(reported.map((sensor) => [sensor.id, sensor]));+ const labelCounts = new Map<string, number>();+ reported.forEach((sensor) => {+ const labelKey = `${sensor.chip}\u0000${sensor.label}`;+ labelCounts.set(labelKey, (labelCounts.get(labelKey) ?? 0) + 1);+ });++ const sensorIds = new Set(+ reported.filter((sensor) => sensor.status === 'ok').map((sensor) => sensor.id),+ );+ configuredSensorIdsByHost.get(hostId)?.forEach((sensorId) => sensorIds.add(sensorId));++ sensorIds.forEach((sensorId) => {+ const resourceId = agentSensorResourceId(hostId, sensorId);+ const override = overridesMap.get(resourceId);+ const sensor = reportedById.get(sensorId);+ const label = sensor?.label.trim() || sensorId;+ const name =+ sensor && (labelCounts.get(`${sensor.chip}\u0000${sensor.label}`) ?? 0) > 1+ ? `${label} (${sensor.channel})`+ : label;+ const chip = sensor?.chip || sensorId.split('/')[0] || '';+ let readingMessage: string | undefined;+ let reading: string | undefined;+ if (!sensor) {+ readingMessage = 'Not reported by this machine. Saved alert settings are retained.';+ } else if (!hostReporting) {+ readingMessage = 'Machine is not reporting, so there is no current reading.';+ } else if (sensor.status !== 'ok' || typeof sensor.value !== 'number') {+ readingMessage = 'No valid reading from this sensor.';+ } else {+ reading = formatTemperature(sensor.value, { decimals: 1 });+ }++ seen.add(resourceId);+ sensors.push({+ id: resourceId,+ name,+ displayName: name,+ rawName: sensorId,+ type: 'agentSensor' as const,+ resourceType: 'Machine Sensor',+ groupKey: agentResource.id,+ node: agentDisplayName,+ instance: chip,+ status: agentResource.status,+ // The default is presentation-only, so any stored entry is an+ // override: a saved 0 stays visible and removable.+ hasOverride: Boolean(override),+ note: override?.note,+ disabled: override?.disabled || false,+ thresholds: override?.thresholds || {},+ defaults: { temperature: 0 },+ presentationDefaults: true,+ subtitle: reading ? `${reading} · ${chip}` : chip,+ readingMessage,+ } satisfies TableResource);+ });+ });++ (props.overrides() ?? [])+ .filter((override) => override.type === 'agentSensor' && !seen.has(override.id))+ .forEach((override) => {+ const parsed = parseAgentSensorResourceId(override.id);+ const name = parsed?.sensorId || override.name || override.id;+ sensors.push({+ id: override.id,+ name,+ displayName: name,+ rawName: name,+ type: 'agentSensor' as const,+ resourceType: 'Machine Sensor',+ groupKey: parsed?.hostId || override.node || 'Unknown Machine',+ node: override.node || parsed?.hostId || 'Unknown Machine',+ instance: '',+ status: 'unknown',+ hasOverride: true,+ disabled: override.disabled || false,+ thresholds: override.thresholds || {},+ defaults: { temperature: 0 },+ presentationDefaults: true,+ note: override.note,+ readingMessage: 'Machine not found. Saved alert settings are retained.',+ } satisfies TableResource);+ });++ return search+ ? sensors.filter(+ (sensor) =>+ sensor.name.toLowerCase().includes(search) ||+ sensor.rawName?.toLowerCase().includes(search) ||+ sensor.node?.toLowerCase().includes(search),+ )+ : sensors;+ }, []);++ // Grouped by the machine's resource ID, not its display name, so two+ // machines with the same name keep separate sensor lists.+ const agentSensorsGroupedByAgent = createMemo<Record<string, TableResource[]>>(() => {+ const grouped: Record<string, TableResource[]> = {};+ agentSensorsWithOverrides().forEach((sensor) => {+ const key =+ typeof sensor.groupKey === 'string' && sensor.groupKey+ ? sensor.groupKey+ : 'Unknown Machine';+ (grouped[key] ??= []).push(sensor);+ });+ Object.values(grouped).forEach((resources) => {+ resources.sort((a, b) => a.name.localeCompare(b.name));+ });+ return grouped;+ });+const agentGroupHeaderMeta = createMemo<Record<string, GroupHeaderMeta>>(() => {const meta: Record<string, GroupHeaderMeta> = {};(props.agents ?? []).forEach((agent) => {@@ -293,6 +445,8 @@ export function useThresholdsHostData(inputs: ThresholdsDataInputs) {agentsWithOverrides,agentDisksWithOverrides,agentDisksGroupedByAgent,+ agentSensorsWithOverrides,+ agentSensorsGroupedByAgent,agentGroupHeaderMeta,};}diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.ts b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.tsindex 2391949cc7..5701e3bc1b 100644--- a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.ts+++ b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsOverrideMutations.ts@@ -1,5 +1,6 @@import type { Accessor } from 'solid-js';+import { alertResourceThresholdsEquivalent } from '@/components/Alerts/alertResourceTableModel';import type { RawOverrideConfig } from '@/types/alerts';import type {Override,@@ -23,6 +24,7 @@ interface ThresholdsOverrideMutationResources {nodesWithOverrides: Accessor<TableResource[]>;agentsWithOverrides: Accessor<TableResource[]>;agentDisksWithOverrides: Accessor<TableResource[]>;+ agentSensorsWithOverrides?: Accessor<TableResource[]>;guestDisksWithOverrides?: Accessor<TableResource[]>;dockerHostsWithOverrides: Accessor<TableResource[]>;guestsFlat: Accessor<TableResource[]>;@@ -69,6 +71,7 @@ export function useThresholdsOverrideMutations({...resources.nodesWithOverrides(),...resources.agentsWithOverrides(),...resources.agentDisksWithOverrides(),+ ...optionalResources(resources.agentSensorsWithOverrides),...optionalResources(resources.guestDisksWithOverrides),...resources.dockerHostsWithOverrides(),...resources.pbsServersWithOverrides(),@@ -95,6 +98,19 @@ export function useThresholdsOverrideMutations({const findThresholdResource = (resourceId: string) =>allThresholdResources().find((entry) => entry.id === resourceId);+ // An edited value that equals the row's default stores nothing. Where the+ // defaults are presentation-only (machine sensors, which have no default),+ // any Off value equals the Off default; elsewhere an explicit Off stays an+ // override, so it survives a later change to the inherited default.+ const matchesDefault = (+ resource: TableResource,+ value: number | undefined,+ defaultValue: number | undefined,+ ) =>+ resource.presentationDefaults+ ? alertResourceThresholdsEquivalent(value, defaultValue)+ : value === defaultValue;+const removeOverride = (resourceId: string) => {const resource = findThresholdResource(resourceId);props.setOverrides(stripOverrideCandidates(props.overrides(), resource));@@ -121,7 +137,7 @@ export function useThresholdsOverrideMutations({if (key === 'backup' || key === 'snapshot') return;const editedValue = editedThresholdMap[key];const defaultValue = defaultThresholds[key];- if (editedValue !== undefined && editedValue !== defaultValue) {+ if (editedValue !== undefined && !matchesDefault(resource, editedValue, defaultValue)) {overrideThresholds[key] = editedValue;}});@@ -246,7 +262,7 @@ export function useThresholdsOverrideMutations({if (key === 'backup' || key === 'snapshot') return;if (thresholds[key] !== undefined) {const value = thresholds[key];- if (value === defaultThresholds[key]) {+ if (matchesDefault(resource, value, defaultThresholds[key])) {delete newThresholds[key];} else {newThresholds[key] = value as number;diff --git a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.ts b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.tsindex a24a8747a7..aa00583bd3 100644--- a/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.ts+++ b/frontend-modern/src/features/alerts/thresholds/hooks/useThresholdsTableState.ts@@ -9,6 +9,8 @@ import { logger } from '@/utils/logger';import {AGENT_DISKS_EMPTY_STATE,AGENT_DISKS_FILTER_EMPTY_STATE,+ AGENT_SENSORS_EMPTY_STATE,+ AGENT_SENSORS_FILTER_EMPTY_STATE,AGENT_THRESHOLDS_FILTER_EMPTY_STATE,getAlertThresholdsHelpBanner,getAlertThresholdsGuestFilterPresentation,@@ -56,6 +58,7 @@ const HELP_BANNER_KEY = 'pulse-thresholds-help-dismissed';interface ThresholdsSummaryItem {key:| 'agentDisks'+ | 'agentSensors'| 'agents'| 'backups'| 'dockerContainers'@@ -276,6 +279,8 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {agentsWithOverrides: rawAgentsWithOverrides,agentDisksWithOverrides: rawAgentDisksWithOverrides,agentDisksGroupedByAgent: rawAgentDisksGroupedByAgent,+ agentSensorsWithOverrides: rawAgentSensorsWithOverrides = () => [],+ agentSensorsGroupedByAgent: rawAgentSensorsGroupedByAgent = () => ({}),agentGroupHeaderMeta,dockerHostsWithOverrides: rawDockerHostsWithOverrides,dockerContainersGroupedByHost: rawDockerContainersGroupedByHost,@@ -342,6 +347,12 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {const agentDisksGroupedByAgent = createMemo(() =>filterGroupedResources(rawAgentDisksGroupedByAgent()),);+ const agentSensorsWithOverrides = createMemo(() =>+ filterResources(rawAgentSensorsWithOverrides()),+ );+ const agentSensorsGroupedByAgent = createMemo(() =>+ filterGroupedResources(rawAgentSensorsGroupedByAgent()),+ );const dockerHostsWithOverrides = createMemo(() => filterResources(rawDockerHostsWithOverrides()));const dockerContainersGroupedByHost = createMemo(() =>filterGroupedResources(rawDockerContainersGroupedByHost()),@@ -546,6 +557,13 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {tab: 'systems',total: agentDisksWithOverrides().length,},+ {+ key: 'agentSensors',+ label: 'Machine Sensors',+ overrides: countOverrides(rawAgentSensorsWithOverrides()),+ tab: 'systems',+ total: agentSensorsWithOverrides().length,+ },{key: 'storage',label: 'Storage',@@ -741,6 +759,7 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {nodesWithOverrides,agentsWithOverrides,agentDisksWithOverrides,+ agentSensorsWithOverrides,guestDisksWithOverrides,dockerHostsWithOverrides,guestsFlat,@@ -775,6 +794,7 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {nodesWithOverrides,agentsWithOverrides,agentDisksWithOverrides,+ agentSensorsWithOverrides,guestDisksWithOverrides,dockerHostsWithOverrides,guestsFlat,@@ -881,6 +901,8 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {agentDisksGroupedByAgent,agentGroupHeaderMeta,agentDisksWithOverrides,+ agentSensorsGroupedByAgent,+ agentSensorsWithOverrides,agentsWithOverrides,alertsEnabled,backupDefaultsRecord,@@ -997,6 +1019,8 @@ export function useThresholdsTableState(props: ThresholdsTableProps) {setSearchTerm,AGENT_DISKS_EMPTY_STATE,AGENT_DISKS_FILTER_EMPTY_STATE,+ AGENT_SENSORS_EMPTY_STATE,+ AGENT_SENSORS_FILTER_EMPTY_STATE,AGENT_THRESHOLDS_FILTER_EMPTY_STATE,getAlertThresholdsHelpBanner,getAlertThresholdsHelpDismissLabel,diff --git a/frontend-modern/src/features/alerts/thresholds/tableTypes.ts b/frontend-modern/src/features/alerts/thresholds/tableTypes.tsindex b17535c7f5..a290d98671 100644--- a/frontend-modern/src/features/alerts/thresholds/tableTypes.ts+++ b/frontend-modern/src/features/alerts/thresholds/tableTypes.ts@@ -24,6 +24,8 @@ export interface Resource {readingMessage?: string;thresholds?: AlertResourceThresholdMap;defaults?: AlertResourceThresholdMap;+ /** Defaults are display-only (no inherited policy), so an Off value is no override. */+ presentationDefaults?: boolean;disabled?: boolean;disableConnectivity?: boolean;poweredOffSeverity?: 'warning' | 'critical';diff --git a/frontend-modern/src/features/alerts/thresholds/types.ts b/frontend-modern/src/features/alerts/thresholds/types.tsindex 338c601d5c..35c62a5bbc 100644--- a/frontend-modern/src/features/alerts/thresholds/types.ts+++ b/frontend-modern/src/features/alerts/thresholds/types.ts@@ -13,6 +13,7 @@ export type OverrideType =| 'guestDisk'| 'agent'| 'agentDisk'+ | 'agentSensor'| 'storage'| 'pbs'| 'pmg'@@ -75,7 +76,11 @@ export interface SimpleThresholds {}export interface ThresholdsTableProps {- onConfigureResourceIntent?: (resourceId: string, signal: AlertIntentSignal) => void;+ onConfigureResourceIntent?: (+ resourceId: string,+ signal: AlertIntentSignal,+ label?: string,+ ) => void;overrides: () => Override[];setOverrides: (overrides: Override[]) => void;rawOverridesConfig: () => Record<string, RawOverrideConfig>;diff --git a/frontend-modern/src/features/alerts/types.ts b/frontend-modern/src/features/alerts/types.tsindex c003f54ff1..92292cb34d 100644--- a/frontend-modern/src/features/alerts/types.ts+++ b/frontend-modern/src/features/alerts/types.ts@@ -92,6 +92,7 @@ export type OverrideType =| 'guestDisk'| 'agent'| 'agentDisk'+ | 'agentSensor'| 'storage'| 'pbs'| 'pmg'@@ -122,6 +123,7 @@ export interface Override {disabled?: boolean; // Completely disable alerts for this guest/storagedisableConnectivity?: boolean; // For nodes/agents - disable offline/connectivity alertspoweredOffSeverity?: 'warning' | 'critical';+ note?: string; // Operator's note on the overridebackup?: BackupAlertConfig;snapshot?: SnapshotAlertConfig;thresholds: {diff --git a/frontend-modern/src/types/api.ts b/frontend-modern/src/types/api.tsindex 2c07e4991d..c07940ef8a 100644--- a/frontend-modern/src/types/api.ts+++ b/frontend-modern/src/types/api.ts@@ -584,11 +584,31 @@ export interface HostSensorSummary {powerWatts?: Record<string, number>;additional?: Record<string, number>;custom?: HostCustomSensorMetric[];+ native?: HostNativeSensor[];gpu?: HostGPUSensor[];thermalState?: HostThermalState;smart?: HostDiskSMART[]; // S.M.A.R.T. disk data}+/**+ * One lm-sensors temperature or fan input from the host agent's inventory.+ * `id` is the host-scoped "<chip>/<channel>" source key (e.g.+ * "applesmc-isa-0300/temp1"), not a physical-device identity; `label` is the+ * chip's original feature name and is not unique. `invalid` marks an+ * implausible reading, and `value` is absent when the chip gave no number.+ */+export interface HostNativeSensor {+ id: string;+ chip: string;+ adapter?: string;+ channel: string;+ label: string;+ kind: 'temperature' | 'fan';+ unit: 'celsius' | 'rpm';+ value?: number;+ status: 'ok' | 'invalid';+}+export interface HostCustomSensorMetric {id: string;name: string;diff --git a/frontend-modern/src/utils/__tests__/alertThresholdsPresentation.test.ts b/frontend-modern/src/utils/__tests__/alertThresholdsPresentation.test.tsindex 9d18a65d23..61ef25f604 100644--- a/frontend-modern/src/utils/__tests__/alertThresholdsPresentation.test.ts+++ b/frontend-modern/src/utils/__tests__/alertThresholdsPresentation.test.ts@@ -212,6 +212,7 @@ describe('alertThresholdsPresentation', () => {pmg: 'Mail Gateway Thresholds',agents: 'Machines',agentDisks: 'Machine Disks',+ agentSensors: 'Machine Sensors',dockerHosts: 'Container Runtimes',dockerContainers: 'Containers',});diff --git a/frontend-modern/src/utils/alertThresholdsPresentation.ts b/frontend-modern/src/utils/alertThresholdsPresentation.tsindex fff86863be..5de7f50388 100644--- a/frontend-modern/src/utils/alertThresholdsPresentation.ts+++ b/frontend-modern/src/utils/alertThresholdsPresentation.ts@@ -22,6 +22,9 @@ export const AGENT_THRESHOLDS_FILTER_EMPTY_STATE = 'No machines match the currenexport const AGENT_DISKS_EMPTY_STATE ='No machine disks found. Machines with mounted filesystems will appear here.';export const AGENT_DISKS_FILTER_EMPTY_STATE = 'No machine disks match the current filters.';+export const AGENT_SENSORS_EMPTY_STATE =+ 'No machine sensors found. Linux machines with lm-sensors temperature inputs will appear here.';+export const AGENT_SENSORS_FILTER_EMPTY_STATE = 'No machine sensors match the current filters.';export const CONTAINER_RUNTIMES_FILTER_EMPTY_STATE ='No container runtimes match the current filters.';export const CONTAINERS_FILTER_EMPTY_STATE = 'No containers match the current filters.';@@ -91,6 +94,7 @@ export const ALERT_THRESHOLDS_SECTION_TITLE_STORAGE = 'Storage Devices';export const ALERT_THRESHOLDS_SECTION_TITLE_PMG = 'Mail Gateway Thresholds';export const ALERT_THRESHOLDS_SECTION_TITLE_AGENTS = 'Machines';export const ALERT_THRESHOLDS_SECTION_TITLE_AGENT_DISKS = 'Machine Disks';+export const ALERT_THRESHOLDS_SECTION_TITLE_AGENT_SENSORS = 'Machine Sensors';export const ALERT_THRESHOLDS_SECTION_TITLE_DOCKER_HOSTS = 'Container Runtimes';export const ALERT_THRESHOLDS_SECTION_TITLE_DOCKER_CONTAINERS = 'Containers';@@ -202,6 +206,7 @@ export function getAlertThresholdsSectionTitles() {pmg: ALERT_THRESHOLDS_SECTION_TITLE_PMG,agents: ALERT_THRESHOLDS_SECTION_TITLE_AGENTS,agentDisks: ALERT_THRESHOLDS_SECTION_TITLE_AGENT_DISKS,+ agentSensors: ALERT_THRESHOLDS_SECTION_TITLE_AGENT_SENSORS,dockerHosts: ALERT_THRESHOLDS_SECTION_TITLE_DOCKER_HOSTS,dockerContainers: ALERT_THRESHOLDS_SECTION_TITLE_DOCKER_CONTAINERS,} as const;diff --git a/internal/mock/generator.go b/internal/mock/generator.goindex 2b86ec4e56..6eed541169 100644--- a/internal/mock/generator.go+++ b/internal/mock/generator.go@@ -3777,6 +3777,9 @@ func generateHosts(config MockConfig) []models.Host {}}}+ if profile.Platform == "linux" {+ sensors.Native = mockHostNativeSensors(hostID, now)+ }status := "online"if rand.Float64() < 0.04 {@@ -4190,6 +4193,90 @@ func syncMockKubernetesNodeHosts(data *models.StateSnapshot) {}}+// mockNativeSensorSpec is one lm-sensors input of a mock machine. offset+// shifts the shared temperature series so sensors on one host differ, and+// invalid marks the implausible reading some chips report (-127 °C).+type mockNativeSensorSpec struct {+ chip string+ adapter string+ channel string+ label string+ offset float64+ invalid bool+}++var (+ mockNativeIntelSensors = []mockNativeSensorSpec{+ {chip: "coretemp-isa-0000", adapter: "ISA adapter", channel: "temp1", label: "Package id 0"},+ {chip: "coretemp-isa-0000", adapter: "ISA adapter", channel: "temp2", label: "Core 0", offset: -2},+ {chip: "coretemp-isa-0000", adapter: "ISA adapter", channel: "temp3", label: "Core 1", offset: -3},+ }+ mockNativeNVMeSensors = []mockNativeSensorSpec{+ {chip: "nvme-pci-0100", adapter: "PCI adapter", channel: "temp1", label: "Composite", offset: -8},+ {chip: "nvme-pci-0200", adapter: "PCI adapter", channel: "temp1", label: "Composite", offset: -6},+ }+ // An Intel Mac running Linux exposes its SMC sensors through applesmc,+ // including the battery (TB0T) and a probe that reads -127 °C.+ mockNativeAppleSMCSensors = []mockNativeSensorSpec{+ {chip: "applesmc-isa-0300", adapter: "ISA adapter", channel: "temp1", label: "TB0T", offset: -20},+ {chip: "applesmc-isa-0300", adapter: "ISA adapter", channel: "temp2", label: "TB1T", invalid: true},+ {chip: "applesmc-isa-0300", adapter: "ISA adapter", channel: "temp3", label: "TC0P", offset: -4},+ {chip: "applesmc-isa-0300", adapter: "ISA adapter", channel: "temp4", label: "Th1H", offset: -9},+ }+)++// mockHostNativeSensors returns a Linux mock machine's native sensor+// inventory. Every machine has CPU core sensors and two NVMe drives whose+// labels repeat across chips; about one machine in four is an Intel Mac whose+// SMC sensors, an invalid one among them, are listed too. A fan input shows+// the inventory is not temperature-only.+func mockHostNativeSensors(hostID string, now time.Time) []models.HostNativeSensor {+ specs := append([]mockNativeSensorSpec{}, mockNativeIntelSensors...)+ specs = append(specs, mockNativeNVMeSensors...)+ appleSMC := mockStableHash64(hostID, "native-sensors-applesmc")%4 == 0+ if appleSMC {+ specs = append(specs, mockNativeAppleSMCSensors...)+ }+ base := SampleMetric("agent", hostID, "temperature", now)+ sensors := make([]models.HostNativeSensor, 0, len(specs)+1)+ for _, spec := range specs {+ value := base + spec.offset+ status := "ok"+ if spec.invalid {+ value = -127+ status = "invalid"+ }+ value = math.Round(value*10) / 10+ sensors = append(sensors, models.HostNativeSensor{+ ID: spec.chip + "/" + spec.channel,+ Chip: spec.chip,+ Adapter: spec.adapter,+ Channel: spec.channel,+ Label: spec.label,+ Kind: "temperature",+ Unit: "celsius",+ Value: &value,+ Status: status,+ })+ }+ if appleSMC {+ rpm := float64(1800 + mockStableHash64(hostID, "native-sensors-fan")%400)+ sensors = append(sensors, models.HostNativeSensor{+ ID: "applesmc-isa-0300/fan1",+ Chip: "applesmc-isa-0300",+ Adapter: "ISA adapter",+ Channel: "fan1",+ Label: "Left side",+ Kind: "fan",+ Unit: "rpm",+ Value: &rpm,+ Status: "ok",+ })+ }+ sort.Slice(sensors, func(i, j int) bool { return sensors[i].ID < sensors[j].ID })+ return sensors+}+func ensureMockFixtureHostIORates(data *models.StateSnapshot) {if data == nil {return@@ -7211,6 +7298,9 @@ func updateHosts(data *models.StateSnapshot, config MockConfig, now time.Time) {}refreshMockHostCPUSensors(host, now)+ if len(host.Sensors.Native) > 0 {+ host.Sensors.Native = mockHostNativeSensors(host.ID, now)+ }if len(host.LoadAverage) == 3 {for j := range host.LoadAverage {diff --git a/internal/mock/generator_test.go b/internal/mock/generator_test.goindex 9395450507..e6ce6fe28e 100644--- a/internal/mock/generator_test.go+++ b/internal/mock/generator_test.go@@ -1690,3 +1690,97 @@ func TestGenerateDockerContainerUpdateStatusLocalImageShape(t *testing.T) {t.Fatal("generator never produced the local image state")}}++// The mock native inventory must look like an ingested agent report: ids are+// "<chip>/<channel>", sorted and unique, status matches the reading, and only+// some machines are Intel Macs with applesmc sensors (an invalid one among+// them) so the Thresholds sensor section has realistic rows to show.+func TestMockHostNativeSensorsMatchIngestedInventoryShape(t *testing.T) {+ now := time.Date(2026, 11, 1, 10, 0, 0, 0, time.UTC)+ appleSMCHosts := 0+ for i := 1; i <= 40; i++ {+ hostID := fmt.Sprintf("host-linux-%d", i)+ sensors := mockHostNativeSensors(hostID, now)+ if len(sensors) == 0 {+ t.Fatalf("%s: empty native inventory", hostID)+ }+ seen := make(map[string]bool, len(sensors))+ hasAppleSMC := false+ for idx, sensor := range sensors {+ if sensor.ID != sensor.Chip+"/"+sensor.Channel {+ t.Fatalf("%s: id %q is not chip/channel", hostID, sensor.ID)+ }+ if seen[sensor.ID] {+ t.Fatalf("%s: duplicate id %q", hostID, sensor.ID)+ }+ seen[sensor.ID] = true+ if idx > 0 && sensors[idx-1].ID >= sensor.ID {+ t.Fatalf("%s: inventory not sorted at %q", hostID, sensor.ID)+ }+ if sensor.Value == nil {+ t.Fatalf("%s: %s has no value", hostID, sensor.ID)+ }+ switch sensor.Kind {+ case "temperature":+ valid := *sensor.Value >= -55 && *sensor.Value <= 150+ if valid != (sensor.Status == "ok") {+ t.Fatalf("%s: %s reads %v with status %q", hostID, sensor.ID, *sensor.Value, sensor.Status)+ }+ if sensor.Unit != "celsius" {+ t.Fatalf("%s: %s unit %q", hostID, sensor.ID, sensor.Unit)+ }+ case "fan":+ if sensor.Unit != "rpm" || sensor.Status != "ok" {+ t.Fatalf("%s: fan %s unit %q status %q", hostID, sensor.ID, sensor.Unit, sensor.Status)+ }+ default:+ t.Fatalf("%s: %s kind %q", hostID, sensor.ID, sensor.Kind)+ }+ if strings.HasPrefix(sensor.Chip, "applesmc-") {+ hasAppleSMC = true+ }+ }+ if hasAppleSMC {+ appleSMCHosts+++ if !seen["applesmc-isa-0300/temp1"] || !seen["applesmc-isa-0300/temp2"] {+ t.Fatalf("%s: applesmc inventory missing TB0T or the invalid TB1T", hostID)+ }+ }+ if again := mockHostNativeSensors(hostID, now); len(again) != len(sensors) {+ t.Fatalf("%s: inventory size changed between calls: %d then %d", hostID, len(sensors), len(again))+ }+ }+ if appleSMCHosts == 0 || appleSMCHosts == 40 {+ t.Fatalf("applesmc hosts = %d of 40, want some but not all", appleSMCHosts)+ }+}++// The ordinary host update refreshes a native inventory with its CPU sensors,+// and leaves hosts without one alone.+func TestUpdateHostsRefreshesNativeSensorInventory(t *testing.T) {+ start := time.Date(2026, 11, 1, 10, 0, 0, 0, time.UTC)+ later := start.Add(37 * time.Minute)+ data := &models.StateSnapshot{Hosts: []models.Host{+ {ID: "host-linux-1", Status: "online", Sensors: models.HostSensorSummary{+ TemperatureCelsius: map[string]float64{"cpu_package": 40},+ Native: mockHostNativeSensors("host-linux-1", start),+ }},+ {ID: "host-windows-1", Status: "online"},+ }}++ updateHosts(data, MockConfig{RandomMetrics: true}, later)++ want := mockHostNativeSensors("host-linux-1", later)+ got := data.Hosts[0].Sensors.Native+ if len(got) != len(want) {+ t.Fatalf("native inventory has %d entries, want %d", len(got), len(want))+ }+ for i := range want {+ if got[i].ID != want[i].ID || *got[i].Value != *want[i].Value || got[i].Status != want[i].Status {+ t.Fatalf("entry %d = %s %v %s, want %s %v %s", i, got[i].ID, *got[i].Value, got[i].Status, want[i].ID, *want[i].Value, want[i].Status)+ }+ }+ if data.Hosts[1].Sensors.Native != nil {+ t.Fatalf("host without an inventory gained one: %+v", data.Hosts[1].Sensors.Native)+ }+}