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
Withdraw stopped VM filesystem readings from canonical History
pulse-triage[bot]ea05ef0f0978
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 3760627ba8..e3ef7fe993 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -20,6 +20,30 @@## Purpose+### Canonical VM History respects native filesystem power state (12 October 2026)++The canonical resource drawer uses `getWorkloadGuestDiskRead`, the same VM+filesystem admission as Workloads and Alerts. Proxmox `runtimeStatus` takes+precedence over canonical status from a linked source; absent native state+falls back to canonical status, with `offline` treated as stopped. A stopped+VM exposes neither a current disk/usage fallback nor a last-known disk carrier,+even with a `prev-` reason or refreshed Last seen. The stopped explanation is+visible beside History. Running retained/unavailable reads keep their existing+distinction; an accepted zero is still current.++Stored history remains inspectable, and independent CPU/memory/network metrics,+LXC platform storage and non-Proxmox resources do not inherit VM filesystem+rules. Power/read snapshot changes do not initiate a History refresh or a guest+operation. This does not establish thaw, writes, restart recovery or release+availability.++`resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts` covers native+and fallback state, platform scopes, zero, reason precedence and independent+resource types. `ResourceDetailDrawer.history.test.tsx` connects reactive+same-ID snapshots to the production drawer and History client. The production+desktop Chromium/phone WebKit fixture `browser-tests/resource-stopped-filesystem.cjs`+also preserves stored observations and trusted keyboard inspection.+### Existing alert History distinguishes failed reads from empty resultsThe History tab renders fixed non-provider error copy in a `role="alert"`diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.cjs b/frontend-modern/browser-tests/resource-stopped-filesystem.cjsnew file mode 100644index 0000000000..281f415b12--- /dev/null+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.cjs@@ -0,0 +1,379 @@+const assert = require('node:assert/strict');+const fs = require('node:fs');+const path = require('node:path');+const crypto = require('node:crypto');+const { chromium, webkit } = require('playwright');+const root = '/workspace/frontend-modern';+const origin = 'http://127.0.0.1:5343';+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');+const runtime = [+ 'frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts',+ 'frontend-modern/src/components/Infrastructure/useResourceDetailDrawerDerivedState.ts',+ 'frontend-modern/src/components/Infrastructure/ResourceDetailDrawer.tsx',+ 'frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx',+ 'frontend-modern/src/utils/workloadGuestPresentation.ts',+];+const settle = (page) =>+ page.evaluate(async () => {+ await document.fonts.ready;+ await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));+ });++async function verify(original = false) {+ const output = `/workspace/tmp/resource-stopped-filesystem/browser-${original ? 'original' : 'final'}`;+ fs.mkdirSync(output, { recursive: true });+ const result = {+ result: 'incomplete',+ phase: original ? 'original-adverse-observation' : 'candidate-verification',+ playwright: require('playwright/package.json').version,+ runtime_hashes: Object.fromEntries(runtime.map((file) => [file, hash('/workspace/' + file)])),+ cases: [],+ screenshots: [],+ cleanup: { browsers: false, server: false },+ limits:+ 'Production ResourceDetailDrawer, History/client and CSS; synthetic snapshots and local endpoints. No native guest command, QGA, thaw, writes, restart, reporter, installed or release acceptance.',+ };+ assert.equal(+ result.playwright,+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[+ 'node_modules/@playwright/test'+ ].version,+ );+ process.chdir(root);+ const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));+ const server = await createServer({+ root,+ configFile: path.join(root, 'vite.config.ts'),+ cacheDir: output + '/cache',+ optimizeDeps: { entries: ['browser-tests/resource-stopped-filesystem.html'] },+ server: { host: '127.0.0.1', port: 5343, strictPort: true },+ });+ let browser;+ try {+ await server.listen();+ for (const [name, engine, width, height, dark] of [+ ['chromium-desktop-light', chromium, 1280, 900, false],+ ['webkit-phone-dark', webkit, 390, 844, true],+ ]) {+ browser = await engine.launch(+ engine === chromium+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }+ : { headless: true },+ );+ const page = await browser.newPage({+ viewport: { width, height },+ isMobile: width < 768,+ hasTouch: width < 768,+ locale: 'en-GB',+ timezoneId: 'UTC',+ });+ page.setDefaultTimeout(12000);+ const record = {+ name,+ width,+ height,+ dark,+ browser: browser.version(),+ errors: [],+ requests: [],+ checks: [],+ states: [],+ };+ result.cases.push(record);+ let mode = 'empty';+ page.on('pageerror', (error) => record.errors.push(error.message));+ await page.route('**/*', (route) => {+ const request = route.request(),+ url = new URL(request.url());+ if (url.origin !== origin) {+ record.requests.push({ path: url.pathname, method: request.method(), blocked: true });+ return route.abort();+ }+ if (!url.pathname.startsWith('/api/')) return route.continue();+ assert.equal(request.method(), 'GET');+ record.requests.push({ path: url.pathname, method: request.method(), mode });+ if (url.pathname === '/api/metrics-store/history') {+ assert.equal(url.searchParams.get('resourceId'), 'fixture:pve:101');+ const end = Date.now() - 60000,+ start = end - 3600000;+ const point = (timestamp, value) => ({ timestamp, value, min: value, max: value });+ return route.fulfill({+ json: {+ resourceType: url.searchParams.get('resourceType'),+ resourceId: 'fixture:pve:101',+ range: url.searchParams.get('range'),+ start,+ end,+ source: 'store',+ metrics: mode === 'stored' ? { disk: [point(start, 25), point(end, 50)] } : {},+ },+ });+ }+ return route.fulfill({+ json:+ url.pathname === '/api/license/runtime-capabilities'+ ? {+ capabilities: [],+ limits: [],+ max_history_days: 90,+ hosted_mode: false,+ runtime: { build: 'community' },+ blocked_capabilities: [],+ }+ : {+ success: true,+ data: [],+ alerts: [],+ anomalies: [],+ config: null,+ capabilities: [],+ relationships: [],+ recentChanges: [],+ available: false,+ audits: [],+ count: 0,+ },+ });+ });+ await page.addInitScript((isDark) => {+ document.addEventListener('DOMContentLoaded', () =>+ document.documentElement.classList.toggle('dark', isDark),+ );+ window.__trustedInputs = [];+ for (const type of ['click', 'keydown'])+ document.addEventListener(+ type,+ (event) => window.__trustedInputs.push({ type, trusted: event.isTrusted }),+ true,+ );+ }, dark);+ await page.goto(origin + '/browser-tests/resource-stopped-filesystem.html', {+ waitUntil: 'domcontentloaded',+ timeout: 60000,+ });+ await page.waitForFunction(() => window.__resourceStoppedFilesystem, null, {+ timeout: 45000,+ });+ const tab = page.getByRole('tab', { name: 'History', exact: true });+ if (width < 768) await tab.tap();+ else {+ await tab.focus();+ await page.keyboard.press('Enter');+ }+ const chart = page.locator('[data-history-group="utilization"]');+ await chart.waitFor();+ await settle(page);+ const apply = async (value) => {+ await page.evaluate((value) => window.__resourceStoppedFilesystem.apply(value), value);+ await settle(page);+ };+ const reads = () =>+ record.requests.filter((request) => request.path === '/api/metrics-store/history').length;+ const firstReads = reads();+ const capture = async (state) => {+ await chart.scrollIntoViewIfNeeded();+ await settle(page);+ const file = `${name}-${state}.png`;+ await chart.screenshot({ path: path.join(output, file) });+ result.screenshots.push({ file, sha256: hash(path.join(output, file)), state, name });+ };+ const unavailable = async () => {+ assert.equal(+ await chart+ .locator('[data-history-current="disk"], [data-history-last-known="disk"]')+ .count(),+ 0,+ );+ assert.match(+ await chart.locator('[data-history-deferred="disk"]').innerText(),+ /while the VM is stopped/,+ );+ assert.doesNotMatch(await chart.innerText(), /90\.0%/);+ };+ if (original) {+ assert.match(+ await chart.locator('[data-history-current="disk"]').innerText(),+ /90\.0%\s*current/,+ );+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);+ record.states.push({ state: 'native-stopped-no-reason', text: await chart.innerText() });+ await capture('stopped-current-carrier');+ await apply({ reason: 'prev-agent-busy' });+ assert.match(+ await chart.locator('[data-history-last-known="disk"]').innerText(),+ /90\.0%\s*last known/,+ );+ assert.doesNotMatch(+ await chart.locator('[data-history-deferred="disk"]').innerText(),+ /VM is stopped/,+ );+ record.states.push({+ state: 'native-stopped-retained-reason',+ text: await chart.innerText(),+ });+ await capture('stopped-retained-carrier');+ record.checks.push(+ 'Native stopped state is ignored with both an empty reason and a retained reason in the original canonical History.',+ );+ } else {+ await unavailable();+ assert.match(+ await chart.locator('[data-history-current="cpu"]').innerText(),+ /10\.0%\s*current/,+ );+ assert.match(+ await chart.locator('[data-history-current="memory"]').innerText(),+ /0\.0%\s*current/,+ );+ assert.equal(await chart.locator('path, [data-history-observation]').count(), 0);+ await capture('stopped');+ record.checks.push(+ 'Native stopped VM withdraws current and retained disk carriers, even when a linked source holds canonical status online; independent CPU/memory are unchanged.',+ );+ await apply({ reason: 'prev-agent-busy' });+ await unavailable();+ await apply({ power: ' STOPPED ', reason: '', seen: Date.now() + 3600000 });+ await unavailable();+ await apply({ power: undefined, status: 'offline' });+ await unavailable();+ record.checks.push(+ 'Stopped native state overrides a prev reason; case/space normalization and legacy offline fallback stay unavailable without a new History read.',+ );+ await apply({ power: ' RUNNING ', status: 'offline', reason: '', usage: 0 });+ assert.match(+ await chart.locator('[data-history-current="disk"]').innerText(),+ /0\.0%\s*current/,+ );+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);+ await capture('current-zero');+ record.checks.push(+ "Explicit native running state wins over another source's offline status, and an accepted zero renders in the existing mounted chart.",+ );+ await apply({+ power: 'running',+ status: 'online',+ reason: 'prev-agent-capacity',+ usage: 90,+ });+ assert.match(+ await chart.locator('[data-history-last-known="disk"]').innerText(),+ /90\.0%\s*last known/,+ );+ assert.match(+ await chart.locator('[data-history-deferred="disk"]').innerText(),+ /guest-read capacity/,+ );+ await capture('retained');+ await apply({ reason: 'agent-capacity' });+ assert.equal(+ await chart+ .locator('[data-history-last-known="disk"], [data-history-current="disk"]')+ .count(),+ 0,+ );+ assert.match(+ await chart.locator('[data-history-deferred="disk"]').innerText(),+ /guest-read capacity/,+ );+ record.checks.push(+ 'Running retained/unavailable read reasons keep their distinct existing semantics, not inferred recovery.',+ );+ await apply({ power: 'stopped', reason: '', platform: 'agent', scopes: ['proxmox-pve'] });+ await unavailable();+ await apply({+ platform: 'vmware-vsphere',+ scopes: undefined,+ reason: 'prev-agent-capacity',+ usage: 30,+ });+ assert.match(+ await chart.locator('[data-history-current="disk"]').innerText(),+ /30\.0%\s*current/,+ );+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);+ assert.equal(reads(), firstReads);+ record.checks.push(+ 'Proxmox-scoped hybrid VM honours native power; a vSphere-only VM does not inherit Proxmox reasons, and snapshot changes send no additional History reads.',+ );+ await apply({+ type: 'system-container',+ platform: 'proxmox-pve',+ power: 'stopped',+ status: 'offline',+ });+ assert.match(+ await chart.locator('[data-history-current="disk"]').innerText(),+ /30\.0%\s*current/,+ );+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);+ record.checks.push(+ 'Independent LXC platform storage remains current despite stopped guest runtime and a VM-only read reason.',+ );+ await apply({ type: 'vm', power: 'stopped', status: 'online', reason: '', usage: 90 });+ await unavailable();+ mode = 'stored';+ const refresh = page.getByRole('button', { name: 'Refresh history', exact: true });+ if (width < 768) await refresh.tap();+ else await refresh.click();+ const slider = chart.getByRole('slider', { name: 'Inspect Utilization history' });+ await slider.waitFor();+ assert.equal(await chart.locator('path').count(), 1);+ await unavailable();+ await slider.focus();+ await page.keyboard.press('Home');+ assert.match(await slider.getAttribute('aria-valuetext'), /Disk 25\.0%/);+ await page.keyboard.press('End');+ assert.match(await slider.getAttribute('aria-valuetext'), /Disk 50\.0%/);+ await capture('stored-stopped');+ record.checks.push(+ 'Stopping withdraws only live carriers, not genuine stored history; trusted keyboard Home/End inspection preserves both disk observations.',+ );+ }+ record.layout = await page.evaluate(() => ({+ width: document.documentElement.clientWidth,+ scrollWidth: document.documentElement.scrollWidth,+ }));+ assert.ok(+ record.layout.scrollWidth <= record.layout.width + 1,+ JSON.stringify(record.layout),+ );+ assert.ok((await page.evaluate(() => window.__trustedInputs)).some((event) => event.trusted));+ assert.deepEqual(record.errors, []);+ assert.equal(+ record.requests.filter((request) => request.blocked || request.method !== 'GET').length,+ 0,+ );+ await browser.close();+ browser = null;+ }+ result.cleanup.browsers = true;+ result.result = 'passed';+ } catch (error) {+ result.result = 'failed';+ result.error = String(error);+ throw error;+ } finally {+ if (browser) {+ await browser.close();+ result.cleanup.browsers = true;+ }+ await server.close();+ result.cleanup.server = true;+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');+ process.stdout.write(+ JSON.stringify({+ result: result.result,+ cases: result.cases.length,+ checks: result.cases.reduce((n, c) => n + c.checks.length, 0),+ cleanup: result.cleanup,+ }) + '\n',+ );+ }+}++module.exports = { verify };+if (require.main === module)+ verify().catch((error) => {+ process.stderr.write(String(error) + '\n');+ process.exitCode = 1;+ });diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.html b/frontend-modern/browser-tests/resource-stopped-filesystem.htmlnew file mode 100644index 0000000000..c253f29419--- /dev/null+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.html@@ -0,0 +1,12 @@+<!doctype html>+<html lang="en">+ <head>+ <meta charset="UTF-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />+ <title>Canonical resource filesystem History verification</title>+ </head>+ <body>+ <div id="root"></div>+ <script type="module" src="/browser-tests/resource-stopped-filesystem.tsx"></script>+ </body>+</html>diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.tsx b/frontend-modern/browser-tests/resource-stopped-filesystem.tsxnew file mode 100644index 0000000000..dc7c35b3b4--- /dev/null+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.tsx@@ -0,0 +1,107 @@+// Synthetic source snapshots only; the drawer, History client and CSS are production.+import { createMemo, createSignal } from 'solid-js';+import { render } from 'solid-js/web';+import { Route, Router } from '@solidjs/router';+import { ResourceDetailDrawer } from '../src/components/Infrastructure/ResourceDetailDrawer';+import { DarkModeContext, WebSocketContext, type WebSocketStore } from '../src/contexts/appRuntime';+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';+import type { Resource } from '../src/types/resource';+import '../src/index.css';++syncAIRuntimeSettings({ discovery_enabled: false });+// Only the empty alert producer is synthetic; no WebSocket connection is opened.+const websocket = {+ activeAlerts: {},+ state: { resources: [] },+ connected: () => true,+} as unknown as WebSocketStore;++type Snapshot = {+ power?: string;+ status: Resource['status'];+ reason: string;+ usage: number;+ type: Resource['type'];+ platform: Resource['platformType'];+ scopes?: Resource['platformScopes'];+ seen: number;+};++function Fixture() {+ const [snapshot, setSnapshot] = createSignal<Snapshot>({+ power: 'stopped',+ status: 'online',+ reason: '',+ usage: 90,+ type: 'vm',+ platform: 'proxmox-pve',+ seen: Date.now(),+ });+ const resource = createMemo<Resource>(() => ({+ id: 'fixture-vm',+ type: snapshot().type,+ name: 'backup-guest',+ displayName: 'Backup guest',+ platformId: 'fixture',+ platformType: snapshot().platform,+ platformScopes: snapshot().scopes,+ sourceType: 'hybrid',+ status: snapshot().status,+ lastSeen: snapshot().seen,+ metricsTarget: {+ resourceType: snapshot().type === 'system-container' ? 'lxc' : 'vm',+ resourceId: 'fixture:pve:101',+ },+ cpu: { current: 10 },+ memory: {+ current: 0,+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-10T00:00:00Z' },+ },+ disk: { current: snapshot().usage },+ network: { rxBytes: 0, txBytes: 200 },+ proxmox: {+ vmid: 101,+ node: 'pve',+ instance: 'fixture',+ runtimeStatus: snapshot().power,+ diskStatusReason: snapshot().reason,+ },+ }));+ Object.assign(window, {+ __resourceStoppedFilesystem: {+ apply: (next: Partial<Snapshot>) => setSnapshot((previous) => ({ ...previous, ...next })),+ resource,+ },+ });+ return (+ <main class="min-h-screen bg-surface p-3 text-base-content">+ <h1 class="text-base font-semibold">Canonical filesystem History</h1>+ <p class="my-2 text-xs text-muted">+ Synthetic power and filesystem observations. No guest operation is sent.+ </p>+ <section class="mx-auto max-w-5xl" aria-label="Production drawer">+ <ResourceDetailDrawer resource={resource()} presentation="table-row" />+ </section>+ </main>+ );+}++render(+ () => (+ <Router>+ <Route+ path="*"+ component={() => (+ <DarkModeContext.Provider+ value={() => document.documentElement.classList.contains('dark')}+ >+ <WebSocketContext.Provider value={websocket}>+ <Fixture />+ </WebSocketContext.Provider>+ </DarkModeContext.Provider>+ )}+ />+ </Router>+ ),+ document.getElementById('root')!,+);diff --git a/frontend-modern/browser-verification/ec3ba02b1d517813.json b/frontend-modern/browser-verification/ec3ba02b1d517813.jsonnew file mode 100644index 0000000000..530c0a9d87--- /dev/null+++ b/frontend-modern/browser-verification/ec3ba02b1d517813.json@@ -0,0 +1,60 @@+{+ "version": 1,+ "base_sha": "7df7f3563f9e30dfd0aa678d8be6b2f7e9a4cca4",+ "verified_at": "2026-10-12T04:20:43Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts": "d496cdf324afac269828ef7ccc7d6fe18855fb49806dca0716a2869a7838a44d"+ },+ "routes": [+ "/browser-tests/resource-stopped-filesystem.html (production canonical ResourceDetailDrawer History and CSS; synthetic sources/local API)"+ ],+ "viewports": [+ {+ "width": 1280,+ "height": 900,+ "browser": "chromium-desktop-light"+ },+ {+ "width": 390,+ "height": 844,+ "browser": "webkit-phone-dark"+ }+ ],+ "states": [+ "Native stopped VM with canonical online and no read reason: no current or last-known disk carrier.",+ "Stopped VM with previous-busy reason, normalized native power and refreshed Last seen remains unavailable.",+ "Missing native state falls back to canonical offline; explicit native running takes precedence and displays accepted zero.",+ "Running retained capacity is last known; running unavailable capacity has no live number.",+ "Hybrid Proxmox-scoped VM retains native power admission; vSphere-only VM and LXC platform storage remain independent.",+ "Genuine stored disk observations remain inspectable for stopped VM."+ ],+ "interactions": [+ "Desktop trusted keyboard Enter opens History; phone trusted tap opens History.",+ "Reactive same-ID synthetic source snapshots exercise native power/read/status transitions without extra History reads before target-type change.",+ "Trusted refresh loads stored disk25% and50%; trusted Home/End slider keys inspect both samples.",+ "Eight chart captures viewed; stopped explanation wraps, no horizontal overflow or page errors on either browser."+ ],+ "proof": {+ "script": "frontend-modern/browser-tests/resource-stopped-filesystem.cjs",+ "playwright": "1.56.1",+ "checks": 14,+ "captures": 8,+ "runtime_hashes": {+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts": "d496cdf324afac269828ef7ccc7d6fe18855fb49806dca0716a2869a7838a44d",+ "frontend-modern/src/components/Infrastructure/useResourceDetailDrawerDerivedState.ts": "94e4b364c744f204ff52e2d28cde6b80a5a66ac414c7ba702113e960a6a67e17",+ "frontend-modern/src/components/Infrastructure/ResourceDetailDrawer.tsx": "9e7ee3e3cbb5f8da38cf43e0aaecd105f43333d16df7338e849d3ccaf6804d8f",+ "frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx": "8b94c3d9409f46bedf812b00ff9f3156da9ace6885ec04456ea5fed59d842127",+ "frontend-modern/src/utils/workloadGuestPresentation.ts": "71a2d2e62411c70c0eb609e68cd4963dac483be59a5be6afcf96c1ce2191436f"+ },+ "result_json_sha256": "bcab014213c55e7f17ddca9e513eee1ab3a3516571d4dfccc2c0862871446375",+ "cleanup": {+ "browsers": true,+ "server": true+ },+ "limits": "Production ResourceDetailDrawer, History/client and CSS; synthetic snapshots and local endpoints. No native guest command, QGA, thaw, writes, restart, reporter, installed or release acceptance."+ }+}diff --git a/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx b/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsxindex f5e53ea7de..30ea9130be 100644--- a/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx+++ b/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx@@ -255,6 +255,73 @@ describe('ResourceDetailDrawer change history section', () => {}});+ it('reactively withdraws stopped VM disk carriers without discarding History or independent readings', async () => {+ resetCreateNonSuspendingQueryCacheForTest();+ const source = baseResource({+ id: 'native-power-vm',+ type: 'vm',+ platformType: 'proxmox-pve',+ metricsTarget: { resourceType: 'vm', resourceId: 'power:pve:101' },+ cpu: { current: 10 },+ memory: {+ current: 0,+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-10T00:00:00Z' },+ },+ disk: { current: 90 },+ proxmox: { runtimeStatus: 'running' },+ });+ const read = vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue({+ resourceType: 'vm',+ resourceId: 'power:pve:101',+ range: '24h',+ start: Date.parse('2026-10-10T00:00:00Z'),+ end: Date.parse('2026-10-10T01:00:00Z'),+ source: 'store',+ metrics: {},+ });+ const [resource, setResource] = createSignal(source);+ const view = render(() => (+ <ResourceDetailDrawer resource={resource()} presentation="table-row" />+ ));+ try {+ fireEvent.click(screen.getByRole('tab', { name: 'History' }));+ await waitFor(() => expect(read).toHaveBeenCalledTimes(1));+ const chart = view.container.querySelector('[data-history-group="utilization"]')!;+ expect(chart.querySelector('[data-history-current="disk"]')).toHaveTextContent(+ '90.0%current',+ );+ for (const diskStatusReason of ['', 'prev-agent-busy']) {+ setResource({+ ...source,+ lastSeen: source.lastSeen + 3600000,+ proxmox: { runtimeStatus: 'stopped', diskStatusReason },+ });+ expect(chart.querySelector('[data-history-current="disk"]')).toBeNull();+ expect(chart.querySelector('[data-history-last-known="disk"]')).toBeNull();+ expect(chart.querySelector('[data-history-deferred="disk"]')).toHaveTextContent(+ 'Guest filesystem stats unavailable while the VM is stopped.',+ );+ expect(chart.querySelector('[data-history-current="memory"]')).toHaveTextContent(+ '0.0%current',+ );+ expect(chart.querySelector('[data-history-current="cpu"]')).toHaveTextContent(+ '10.0%current',+ );+ }+ setResource({ ...source, status: 'offline', disk: { current: 0 } });+ expect(chart.querySelector('[data-history-current="disk"]')).toHaveTextContent('0.0%current');+ expect(chart.querySelector('[data-history-deferred="disk"]')).toBeNull();+ expect(view.container.querySelector('[data-history-group="utilization"]')).toBe(chart);+ expect(chart.querySelector('path')).toBeNull();+ expect(read).toHaveBeenCalledTimes(1);+ expect(screen.getByRole('tab', { name: 'History' })).toHaveAttribute('aria-selected', 'true');+ } finally {+ view.unmount();+ read.mockRestore();+ resetCreateNonSuspendingQueryCacheForTest();+ }+ });+it('keeps current readings separate from stored history samples', () => {expect(guestDrawerHistorySource).toContain('currentMetrics');expect(guestDrawerHistorySource).toContain('No stored history in this range');diff --git a/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts b/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.tsindex 9fe9a0ac3b..1cb61e1fb1 100644--- a/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts+++ b/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts@@ -165,6 +165,85 @@ describe('canonical drawer History honours selected guest observation provenanceexpect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBe(50);},);++ it.each(['stopped', ' STOPPED ', 'offline'])(+ 'withdraws native %s VM disk carriers before considering a retained read reason',+ (runtimeStatus) => {+ for (const diskStatusReason of ['', 'prev-agent-busy']) {+ const value = resource('current', 0);+ value.proxmox = { runtimeStatus, diskStatusReason };+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({+ disk: undefined,+ usage: undefined,+ memory: 0,+ cpu: 10,+ netin: 0,+ });+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toEqual({+ lastKnownValue: undefined,+ message: 'Guest filesystem stats unavailable while the VM is stopped.',+ });+ value.lastSeen += 3600000;+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();+ }+ },+ );++ it('uses native running state over canonical offline, keeping accepted zero current', () => {+ const value = resource('current');+ value.status = 'offline';+ value.proxmox = { runtimeStatus: ' RUNNING ', diskStatusReason: '' };+ value.disk = { current: 0 };+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 0, usage: 0 });+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();+ value.proxmox.diskStatusReason = 'vm-stopped';+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();+ });++ it.each([undefined, '', ' '])(+ 'uses canonical offline only when native state is absent (%s)',+ (runtimeStatus) => {+ const value = resource('current');+ value.status = 'offline';+ value.proxmox = { runtimeStatus };+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.message).toContain(+ 'VM is stopped',+ );+ },+ );++ it('honours native power for a VM with Proxmox among its platform scopes', () => {+ const value = resource('current');+ value.platformType = 'agent';+ value.platformScopes = ['agent', 'proxmox-pve'];+ value.proxmox = { runtimeStatus: 'stopped' };+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();+ });++ it.each(['system-container', 'storage', 'disk', 'agent'] as const)(+ 'does not apply VM filesystem power/read rules to independent %s metrics',+ (type) => {+ const value = resource('current');+ value.type = type;+ value.status = 'offline';+ value.proxmox = { runtimeStatus: 'stopped', diskStatusReason: 'prev-agent-busy' };+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 50, usage: 50 });+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();+ },+ );++ it('leaves a vSphere-only VM independent of Proxmox power/read metadata', () => {+ const value = resource('current');+ value.platformType = 'vmware-vsphere';+ value.platformScopes = ['vmware-vsphere'];+ value.status = 'offline';+ value.proxmox = { runtimeStatus: 'stopped', diskStatusReason: 'prev-agent-busy' };+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 50, usage: 50 });+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();+ });});describe('getResourceMetricsHistoryTarget branch coverage', () => {diff --git a/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts b/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.tsindex 8d4ee55a4b..d0c8a50c8a 100644--- a/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts+++ b/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts@@ -20,7 +20,7 @@ import {} from '@/features/storageBackups/diskTemperaturePresentation';import { asTrimmedString } from '@/utils/stringUtils';import { getMemoryObservationPresentation } from '@/utils/memoryObservation';-import { getWorkloadGuestDiskStatusMessage } from '@/utils/workloadGuestPresentation';+import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';const finiteMetric = (value: number | undefined): number | undefined =>typeof value === 'number' && Number.isFinite(value) ? value : undefined;@@ -173,10 +173,22 @@ const memoryReading = (resource: Resource) =>isProxmoxGuest(resource),);-const diskReadReason = (resource: Resource): string | undefined =>- resource.type === 'vm' && isProxmoxGuest(resource)- ? resource.proxmox?.diskStatusReason || undefined- : undefined;+const guestDiskReading = (resource: Resource) => {+ if (resource.type !== 'vm' || !isProxmoxGuest(resource)) return null;+ // A linked source can keep the canonical resource online while Proxmox+ // reports the VM stopped. Judge filesystem carriers by the native state,+ // using the same read admission as Workloads and Alerts, not Last seen.+ const status = (asTrimmedString(resource.proxmox?.runtimeStatus) || resource.status)+ .trim()+ .toLowerCase();+ return getWorkloadGuestDiskRead(+ {+ status: status === 'offline' ? 'stopped' : status,+ diskStatusReason: resource.proxmox?.diskStatusReason,+ },+ true,+ );+};// A physical disk's reading and its collection state both live on// physicalDisk, so read them only together: websocket rows carry no top-level@@ -203,14 +215,14 @@ export const getResourceMetricsHistoryDeferredMetrics = (message: memory.message,};}- const reason = diskReadReason(resource);- if (reason) {+ const disk = guestDiskReading(resource);+ if (disk && disk.state !== 'current') {metrics.disk = {lastKnownValue:- reason.startsWith('prev-') && resource.disk+ disk.state === 'last-known' && resource.disk? finiteMetric(getDiskPercent(resource)): undefined,- message: getWorkloadGuestDiskStatusMessage(reason),+ message: disk.message,};}if (!isResourceTemperatureCurrent(resource)) {@@ -232,7 +244,11 @@ export const getResourceMetricsHistoryDeferredMetrics = (export const getResourceMetricsHistoryCurrentMetrics = (resource: Resource,): Record<string, number | undefined> => {- const diskPercent = resource.disk ? finiteMetric(getDiskPercent(resource)) : undefined;+ const disk = guestDiskReading(resource);+ const diskPercent =+ resource.disk && (!disk || disk.state === 'current')+ ? finiteMetric(getDiskPercent(resource))+ : undefined;const temperature = isResourceTemperatureCurrent(resource)? finiteMetric(resourceTemperature(resource)): undefined;@@ -243,7 +259,7 @@ export const getResourceMetricsHistoryCurrentMetrics = (resource.memory && (!memory || memory.state === 'current')? finiteMetric(getMemoryPercent(resource)): undefined,- disk: diskReadReason(resource) ? undefined : diskPercent,+ disk: diskPercent,usage: diskPercent,netin: finiteMetric(resource.network?.rxBytes),netout: finiteMetric(resource.network?.txBytes),