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
Keep workload disk measurements distinct from capacity and fractions
pulse-triage[bot]c1a4a8733c92
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex f570d21620..06473823d4 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -20,6 +20,23 @@## Purpose+### Aggregate disk bars preserve percentage-only evidence (14 October 2026)++The shared stacked-disk primitive keeps independently supplied aggregate+percentages in percentage points, including values below 1%. Without a measured+filesystem, it uses the aggregate metric admission in `workloadDiskUsage.ts`;+capacity alone cannot draw a healthy zero. Percentage-only tooltips and labels+withhold missing bytes rather than inventing empty capacity. Measured filesystem+byte ratios, omitted-zero DiskInfo rows, unknown sentinels, per-filesystem+thresholds and source-owned last-known/unavailable decoration remain separate.++Verification: the stacked-disk component/model suites retain filesystem and+host controls; `workloadDiskUsage.test.ts` and the desktop/narrow+`workload-disk-metrics` browser fixture cover aggregate low/zero/byte/unknown+readings through the consuming Workloads row and drawer. A fixture is not a+native measurement or stored History observation.++### Pulse Mobile retirement guidance stays readable (14 October 2026)The existing Pulse Mobile settings surface exposes its retirement guidance asdiff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex a37c84232a..80ff5937d1 100644--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md@@ -15,6 +15,37 @@## Purpose+### Workloads aggregate disk readings keep their units and presence (14 October 2026)++Workload aggregate metrics are percentage points, including values from zero+through one; selection never guesses a fraction from magnitude. A capacity or+used-byte scalar alone is not an aggregate utilization reading. The mapper+preserves missing/invalid aggregate fields, while an explicit finite+non-negative percentage or finite non-negative used bytes with positive+capacity supplies usage. An explicit invalid percentage cannot fall back to+retained byte carriers. Values above 100 are bounded for existing display.++The row (bars and history lens), drawer current/last-known fallback, numeric+search and capacity sorting share this numeric admission. Source-owned guest+read deferrals, linked-agent leases and stopped-VM rules still determine+freshness independently. Unavailable or retained values remain after current+values in both sort directions and cannot match numeric capacity queries.+Percentage-only readings show no invented used/capacity bytes; byte-only+readings and explicit zero remain available. Per-filesystem DiskInfo omitted+zero bytes retain their existing wire semantics and are not aggregate metrics.+No collector, guest request, timer, store/history point, threshold or alert+policy is changed.++Verification: `workloadDiskUsage.test.ts`, `useWorkloads.test.ts` (REST and owning+snapshot refreshes), `workloadSelectors.test.ts`, `GuestRow.test.ts`,+`GuestDrawerHistory.disk-provenance.test.tsx` and stacked-disk tests cover low+percentages, capacity-only absence, explicit zero, byte-only reads and the+unchanged freshness controls. `browser-tests/workload-disk-metrics.tsx` feeds+synthetic REST observations through the production mapper, selection, rows and+full drawer at desktop and phone widths. Its browser result/pixels must be+recorded separately; it proves neither native recovery nor availability.++### Existing Workloads snapshots retain guest interface namesThe Workloads mapper selects the existing agent interface list, otherwise the@@ -592,6 +623,8 @@ in-place click and chevron activation over a selection.## Canonical Files+- `frontend-modern/src/utils/workloadDiskUsage.ts` — aggregate disk numeric/current-reading admission.+- `frontend-modern/src/utils/filesystemByteUsage.ts`: shared finite byte/capacity admission for filesystem utilization.1. `pkg/metrics/store.go`diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex 79bea7069e..5d2b3574b7 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -23,6 +23,23 @@ and sort the complete canonical change table while startup and ingestion wait.## Purpose+### Workload aggregate disk presence survives projection (14 October 2026)++`useWorkloads` does not default an absent aggregate disk usage/used byte field+to zero merely because capacity was supplied. Both REST and owning snapshots+preserve the difference between capacity-only inventory and finite measured+usage. Explicit zero percentages, percentage-only metrics and valid byte-only+metrics remain available. This aggregate metric contract is distinct from+DiskInfo filesystem records whose zero byte fields may be omitted. Identity,+producer selection, collection, retention and History transport are unchanged.++Verification: `useWorkloads.test.ts` exercises mounted REST and owning-snapshot+refreshes and `workloadDiskUsage.test.ts` covers numeric admission. The+`workload-disk-metrics` browser fixture consumes the REST mapper into production+rows/drawer with synthetic evidence; browser proof is retained separately and+establishes no installed/native recovery.++### Workloads preserve platform guest interfaces — issue #2757Both the `/api/resources` and owning canonical-snapshot Workloads projectionsdiff --git a/frontend-modern/browser-tests/build-workload-disk-metrics.mjs b/frontend-modern/browser-tests/build-workload-disk-metrics.mjsnew file mode 100644index 0000000000..93b83dc759--- /dev/null+++ b/frontend-modern/browser-tests/build-workload-disk-metrics.mjs@@ -0,0 +1,99 @@+// Compile the real workload-disk-metrics fixture before bounded browser execution.+// Only a bounded static preview runs in the browser tree; no live compiler or guest command.+import { build } from 'vite';+import solid from 'vite-plugin-solid';+import tailwindcss from '@tailwindcss/vite';+import { stop } from 'esbuild';+import fs from 'node:fs';+import path from 'node:path';+import crypto from 'node:crypto';+import { fileURLToPath } from 'node:url';++const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');+const output = path.resolve(root, '../tmp/workload-disk-metrics-static');+const hash = (data) => crypto.createHash('sha256').update(data).digest('hex');++try {+ for (const variant of ['final']) {+ const sources = {};+ const artifacts = {};+ const outDir = path.join(output, variant);+ await build({+ root,+ // Root-relative assets keep the real shipped Docs viewer functional in a new tab.+ base: '/',+ configFile: false,+ publicDir: false,+ plugins: [+ {+ name: 'exact-workload-disk-metrics-fixture-binding',+ enforce: 'pre',+ generateBundle(_options, bundle) {+ for (const id of this.getModuleIds()) {+ if (!id.startsWith(root + '/') || id.includes('/node_modules/')) continue;+ const file = id.split('?')[0];+ if (!fs.existsSync(file) || !fs.statSync(file).isFile()) continue;+ sources[path.relative(root, file)] = hash(fs.readFileSync(file));+ }+ for (const [file, asset] of Object.entries(bundle)) {+ artifacts[file] = hash(asset.type === 'chunk' ? asset.code : asset.source);+ }+ },+ },+ tailwindcss(),+ solid(),+ ],+ resolve: {+ alias: { '@': path.join(root, 'src') },+ conditions: ['import', 'browser', 'default'],+ },+ build: {+ // Match the application's declared target, not Vite's older default.+ target: 'esnext',+ outDir,+ emptyOutDir: true,+ rollupOptions: { input: path.join(root, 'browser-tests/workload-disk-metrics.html') },+ },+ });+ sources['browser-tests/build-workload-disk-metrics.mjs'] = hash(+ fs.readFileSync(fileURLToPath(import.meta.url)),+ );+ const importedSources = { ...sources };+ const scanInputs = (dir) => {+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {+ const file = path.join(dir, entry.name);+ if (entry.isDirectory()) scanInputs(file);+ else if (/\.(tsx?|css|html)$/.test(file))+ sources[path.relative(root, file)] = hash(fs.readFileSync(file));+ }+ };+ scanInputs(path.join(root, 'src'));+ scanInputs(path.join(root, 'browser-tests'));+ // Hash the bytes actually written, including HTML post-processing.+ const walk = (dir) => {+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {+ const file = path.join(dir, entry.name);+ if (entry.isDirectory()) walk(file);+ else artifacts[path.relative(outDir, file)] = hash(fs.readFileSync(file));+ }+ };+ walk(outDir);+ fs.writeFileSync(+ path.join(outDir, 'binding.json'),+ JSON.stringify(+ {+ variant,+ graph: hash(fs.readFileSync(path.join(root, 'package-lock.json'))),+ builder: hash(fs.readFileSync(fileURLToPath(import.meta.url))),+ sources,+ importedSources,+ artifacts,+ },+ null,+ 2,+ ) + '\n',+ );+ }+} finally {+ stop();+}diff --git a/frontend-modern/browser-tests/workload-disk-metrics.cjs b/frontend-modern/browser-tests/workload-disk-metrics.cjsnew file mode 100644index 0000000000..05726a1171--- /dev/null+++ b/frontend-modern/browser-tests/workload-disk-metrics.cjs@@ -0,0 +1,294 @@+const assert = require('node:assert/strict');+const crypto = require('node:crypto');+const fs = require('node:fs');+const http = require('node:http');+const path = require('node:path');+const { chromium, webkit } = require('playwright');+const root = '/workspace';+const compiled = path.join(root, 'tmp/workload-disk-metrics-static/final');+const output = path.join(root, 'tmp/disk-reading-proof/browser');+const origin = 'http://127.0.0.1:5321';+const hash = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');+const binding = JSON.parse(fs.readFileSync(path.join(compiled, 'binding.json')));+const result = {+ result: 'incomplete',+ playwright: require('playwright/package.json').version,+ scope:+ 'Synthetic Resources REST metrics through production useWorkloads, selection, GuestRow/GuestDrawer/History/CSS. Fixture selection controls, local empty History and supporting APIs, not full-app authentication, native measurements or recovery.',+ binding,+ driver_sha256: hash(fs.readFileSync(__filename)),+ cases: [],+ requests: [],+ captures: [],+ errors: [],+ cleanup: {},+};+const baseMetrics = [+ ['empty', { percent: 0, used: 0, total: 100 }],+ ['half-percent', { percent: 0.5, used: 0.5, total: 100 }],+ ['one-percent', { percent: 1, used: 1, total: 100 }],+ ['forty-percent', { percent: 40, used: 40, total: 100 }],+ ['critical', { percent: 95, used: 95, total: 100 }],+ ['capacity-only', { total: 100 }],+];+const resource = (name, metric, extras = {}) => ({+ id: `fixture-${name}`,+ type: 'vm',+ name,+ status: 'online',+ sources: ['proxmox'],+ platformType: 'proxmox-pve',+ lastSeen: '2026-10-14T19:00:00Z',+ metricsTarget: { resourceType: 'vm', resourceId: `fixture-${name}` },+ metrics: { cpu: { percent: 10 }, memory: { percent: 25, used: 25, total: 100 }, disk: metric },+ proxmox: {+ vmid: 101,+ instance: 'lab',+ nodeName: 'fixture-node',+ runtimeStatus: 'running',+ guestAgentStatus: 'available',+ ...extras,+ },+});+let server;+let browser;+(async () => {+ fs.mkdirSync(output, { recursive: true });+ assert.equal(+ result.playwright,+ JSON.parse(fs.readFileSync(root + '/tests/integration/package-lock.json')).packages[+ 'node_modules/@playwright/test'+ ].version,+ );+ for (const [file, sha] of Object.entries(binding.importedSources))+ assert.equal(hash(fs.readFileSync(root + '/frontend-modern/' + file)), sha, file);+ for (const [file, sha] of Object.entries(binding.artifacts))+ assert.equal(hash(fs.readFileSync(compiled + '/' + file)), sha, file);+ server = http.createServer((req, res) => {+ const pathname = decodeURIComponent(new URL(req.url, origin).pathname);+ const file = path.join(compiled, pathname);+ if (!file.startsWith(compiled + '/') || !fs.existsSync(file) || !fs.statSync(file).isFile()) {+ res.writeHead(404);+ res.end();+ return;+ }+ res.setHeader(+ 'Content-Type',+ file.endsWith('.js') ? 'text/javascript' : file.endsWith('.css') ? 'text/css' : 'text/html',+ );+ res.end(fs.readFileSync(file));+ });+ await new Promise((resolve) => server.listen(5321, '127.0.0.1', resolve));+ try {+ for (const [label, engine, width, dark] of [+ ['desktop', chromium, 1280, false],+ ['phone', webkit, 390, true],+ ]) {+ browser = await engine.launch(+ engine === chromium+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }+ : { headless: true },+ );+ const page = await browser.newPage({+ viewport: { width, height: 1000 },+ hasTouch: width < 640,+ isMobile: width < 640,+ locale: 'en-GB',+ timezoneId: 'UTC',+ });+ page.setDefaultTimeout(12000);+ let resources = baseMetrics.map(([name, metric]) => resource(name, metric));+ const record = { label, width, height: 1000, dark, browser: browser.version(), states: [] };+ result.cases.push(record);+ page.on('pageerror', (error) => result.errors.push({ label, message: error.message }));+ await page.route('**/*', async (route) => {+ const url = new URL(route.request().url());+ assert.equal(url.origin, origin);+ if (!url.pathname.startsWith('/api/')) return route.continue();+ const method = route.request().method();+ result.requests.push({ label, path: url.pathname, method });+ assert.ok(+ method === 'GET' || (method === 'POST' && url.pathname === '/api/usage/workload-history'),+ );+ if (url.pathname === '/api/resources')+ return route.fulfill({ json: { data: resources, meta: { totalPages: 1 } } });+ if (url.pathname === '/api/metrics-store/history')+ return route.fulfill({+ json: {+ resourceType: 'vm',+ resourceId: url.searchParams.get('resourceId'),+ range: url.searchParams.get('range'),+ start: Date.UTC(2026, 9, 14, 18),+ end: Date.UTC(2026, 9, 14, 19),+ source: 'store',+ metrics: {},+ },+ });+ if (url.pathname === '/api/license/runtime-capabilities')+ return route.fulfill({+ json: {+ capabilities: [],+ limits: [],+ max_history_days: 7,+ hosted_mode: false,+ runtime: { build: 'community' },+ blocked_capabilities: [],+ },+ });+ return route.fulfill({+ json: { success: true, data: [], alerts: [], anomalies: [], config: null },+ });+ });+ await page.addInitScript((isDark) => {+ if (isDark)+ document.addEventListener('DOMContentLoaded', () =>+ document.documentElement.classList.add('dark'),+ );+ }, dark);+ await page.goto(origin + '/browser-tests/workload-disk-metrics.html');+ const table = page.getByRole('region', { name: 'Workload readings' });+ const order = () =>+ table+ .locator('tbody tr[data-guest-id]')+ .evaluateAll((rows) =>+ rows.map((row) => row.getAttribute('data-guest-id').replace('fixture-', '')),+ );+ const settle = () =>+ page.evaluate(async () => {+ await document.fonts.ready;+ await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));+ });+ const capture = async (name) => {+ await settle();+ assert.equal(+ await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth),+ true,+ );+ const file = path.join(output, `${label}-${name}.png`);+ await page.screenshot({ path: file, fullPage: true });+ result.captures.push({ label, name, file, sha256: hash(fs.readFileSync(file)) });+ };+ await table.locator('tr[data-guest-id="fixture-capacity-only"]').waitFor();+ assert.deepEqual(await order(), [+ 'critical',+ 'forty-percent',+ 'one-percent',+ 'half-percent',+ 'empty',+ 'capacity-only',+ ]);+ const capacityCell = table.locator(+ '[data-guest-id="fixture-capacity-only"] [data-workload-col="disk"]',+ );+ assert.equal(await capacityCell.locator('[data-animated-number]').count(), 0);+ await capture('descending');+ await page.getByRole('combobox', { name: 'Disk order' }).selectOption('asc');+ assert.deepEqual(await order(), [+ 'empty',+ 'half-percent',+ 'one-percent',+ 'forty-percent',+ 'critical',+ 'capacity-only',+ ]);+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk>90');+ assert.deepEqual(await order(), ['critical']);+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk<=1');+ assert.deepEqual(await order(), ['empty', 'half-percent', 'one-percent']);+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('');+ await page.getByRole('combobox', { name: 'Metrics', exact: true }).selectOption('sparklines');+ const one = table.locator('[data-guest-id="fixture-one-percent"]');+ assert.equal(+ await one.getByRole('img', { name: 'one-percent disk usage history, current 1%' }).count(),+ 1,+ );+ if (width < 640) await table.getByText('capacity-only', { exact: true }).tap();+ else {+ await table.getByRole('button', { name: /capacity-only/ }).focus();+ await page.keyboard.press('Enter');+ }+ const drawer = page.getByRole('region', { name: 'Selected guest' });+ await drawer.locator('[data-history-group="utilization"]').waitFor();+ const current = () => drawer.locator('[data-history-current="disk"]');+ assert.equal(await current().count(), 0);+ assert.equal(await drawer.locator('path[data-history-series]').count(), 0);+ await capture('capacity-only');+ const observe = async (name, metric, extras, expected) => {+ resources = resources.map((row) =>+ row.id === 'fixture-capacity-only'+ ? { ...resource('capacity-only', metric, extras) }+ : row,+ );+ await page.evaluate(() => window.__diskMetrics.refresh());+ await settle();+ const evidence = await page.evaluate(() =>+ window.__diskMetrics.evidence().find((row) => row.id === 'fixture-capacity-only'),+ );+ assert.equal(evidence.current ?? null, expected);+ record.states.push({ name, metric, extras, evidence });+ };+ await observe('percentage-only-low', { percent: 0.5 }, {}, 0.5);+ assert.match(await current().innerText(), /0.5%/);+ assert.equal((await drawer.innerText()).includes('0 B of'), false);+ await capture('percentage-only');+ await observe('explicit-zero', { percent: 0 }, {}, 0);+ assert.match(await current().innerText(), /0.0%/);+ await observe('byte-only', { used: 50, total: 100 }, {}, 50);+ assert.match(await current().innerText(), /50.0%/);+ await page.getByRole('combobox', { name: 'Metrics', exact: true }).selectOption('bars');+ await observe('capacity-only-restored', { total: 100 }, {}, null);+ assert.equal(await current().count(), 0);+ await observe(+ 'retained',+ { percent: 95, used: 95, total: 100 },+ { diskStatusReason: 'prev-agent-busy', guestAgentStatus: 'deferred' },+ null,+ );+ assert.match(await drawer.locator('[data-history-last-known="disk"]').innerText(), /95.0%/);+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk>90');+ assert.deepEqual(await order(), ['critical']);+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('');+ await capture('retained');+ await observe(+ 'unavailable',+ { percent: 95, used: 95, total: 100 },+ { diskStatusReason: 'agent-timeout' },+ null,+ );+ assert.equal(await drawer.locator('[data-history-last-known="disk"]').count(), 0);+ await observe('recovered-current', { percent: 1, used: 1, total: 100 }, {}, 1);+ assert.match(await current().innerText(), /1.0%/);+ assert.equal(await drawer.locator('path[data-history-series]').count(), 0);+ await capture('recovered');+ await drawer.getByRole('button', { name: 'Collapse capacity-only details' }).click();+ assert.equal(await drawer.count(), 0);+ assert.deepEqual(result.errors, []);+ await page.close();+ await browser.close();+ browser = undefined;+ }+ result.result = 'passed';+ } finally {+ if (browser) await browser.close();+ result.cleanup.browser_closed = true;+ await new Promise((resolve) => server.close(resolve));+ result.cleanup.server_closed = true;+ }+})()+ .catch((error) => {+ result.errors.push({ driver: error.stack });+ process.exitCode = 1;+ })+ .finally(() => {+ fs.mkdirSync(output, { recursive: true });+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');+ console.log(+ JSON.stringify({+ result: result.result,+ output,+ captures: result.captures.length,+ errors: result.errors,+ cleanup: result.cleanup,+ }),+ );+ });diff --git a/frontend-modern/browser-tests/workload-disk-metrics.html b/frontend-modern/browser-tests/workload-disk-metrics.htmlnew file mode 100644index 0000000000..62ad1e996f--- /dev/null+++ b/frontend-modern/browser-tests/workload-disk-metrics.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>Workload disk metrics fixture</title>+ </head>+ <body>+ <div id="root"></div>+ <script type="module" src="/browser-tests/workload-disk-metrics.tsx"></script>+ </body>+</html>diff --git a/frontend-modern/browser-tests/workload-disk-metrics.tsx b/frontend-modern/browser-tests/workload-disk-metrics.tsxnew file mode 100644index 0000000000..0aa90502b2--- /dev/null+++ b/frontend-modern/browser-tests/workload-disk-metrics.tsx@@ -0,0 +1,134 @@+// Synthetic REST observations -> production mapper, selection, row and drawer.+// The fixture controls only selection/display, never a guest or backup operation.+import { createMemo, createSignal, For, Show } from 'solid-js';+import { render } from 'solid-js/web';+import { Route, Router } from '@solidjs/router';+import { useWorkloads } from '../src/hooks/useWorkloads';+import { GuestRow } from '../src/components/Workloads/GuestRow';+import { GuestDrawer } from '../src/components/Workloads/GuestDrawer';+import {+ filterWorkloads,+ createWorkloadSortComparator,+} from '../src/components/Workloads/workloadSelectors';+import { getGuestDrawerCurrentMetrics } from '../src/components/Workloads/guestDrawerModel';+import { DarkModeContext } from '../src/contexts/appRuntime';+import '../src/index.css';++function Fixture() {+ const state = useWorkloads(() => true);+ const [search, setSearch] = createSignal('');+ const [direction, setDirection] = createSignal<'asc' | 'desc'>('desc');+ const [mode, setMode] = createSignal<'bars' | 'sparklines'>('bars');+ const [selected, setSelected] = createSignal<string | null>(null);+ const phone = matchMedia('(max-width: 639px)').matches;+ const ordered = createMemo(() =>+ [+ ...filterWorkloads({+ guests: state.workloads(),+ searchTerm: search(),+ viewMode: 'all',+ statusMode: 'all',+ selectedNode: null,+ selectedHostHint: null,+ selectedKubernetesContext: null,+ }),+ ].sort(createWorkloadSortComparator('disk', direction())!),+ );+ const guest = () => state.workloads().find((row) => row.id === selected());+ (window as any).__diskMetrics = {+ refresh: state.refetch,+ evidence: () =>+ state+ .workloads()+ .map((row) => ({+ id: row.id,+ disk: row.disk,+ available: row.telemetryAvailability?.disk,+ current: getGuestDrawerCurrentMetrics(row).disk,+ })),+ };+ return (+ <main class="min-h-screen space-y-3 bg-surface p-3 text-base-content pulse-wide-data-surface">+ <h1 class="text-base font-semibold">Workload disk readings</h1>+ <p class="text-xs text-muted">+ Synthetic observations; fixture selection controls. No guest operations.+ </p>+ <div class="flex flex-wrap gap-2 text-sm">+ <label>+ Search{' '}+ <input+ aria-label="Search fixtures"+ value={search()}+ onInput={(e) => setSearch(e.currentTarget.value)}+ class="w-32 rounded-sm border border-border bg-surface px-2 py-2"+ />+ </label>+ <label>+ Disk order{' '}+ <select+ aria-label="Disk order"+ value={direction()}+ onChange={(e) => setDirection(e.currentTarget.value as 'asc' | 'desc')}+ class="rounded-sm border border-border bg-surface px-2 py-2"+ >+ <option value="asc">Ascending</option>+ <option value="desc">Descending</option>+ </select>+ </label>+ <label>+ Metrics{' '}+ <select+ aria-label="Metrics"+ value={mode()}+ onChange={(e) => setMode(e.currentTarget.value as 'bars' | 'sparklines')}+ class="rounded-sm border border-border bg-surface px-2 py-2"+ >+ <option value="bars">Bars</option>+ <option value="sparklines">Sparklines</option>+ </select>+ </label>+ </div>+ <section aria-label="Workload readings" class="rounded-sm border border-border">+ <table class="workload-table platform-table w-full table-fixed">+ <thead>+ <tr>+ <th class="p-2 text-left">Name</th>+ <th class="p-2 text-center">Disk</th>+ </tr>+ </thead>+ <tbody>+ <For each={ordered()}>+ {(row) => (+ <GuestRow+ guest={row}+ visibleColumnIds={['name', 'disk']}+ metricDisplayMode={mode()}+ workloadTableLayoutMode={phone ? 'phone' : 'wide'}+ onClick={() => setSelected(row.id)}+ />+ )}+ </For>+ </tbody>+ </table>+ </section>+ <Show when={guest()}>+ {(_row) => (+ <section aria-label="Selected guest" class="rounded-sm border border-border p-3">+ <GuestDrawer guest={guest()!} onClose={() => setSelected(null)} />+ </section>+ )}+ </Show>+ </main>+ );+}++render(+ () => (+ <DarkModeContext.Provider value={() => document.documentElement.classList.contains('dark')}>+ <Router>+ <Route path="*" component={Fixture} />+ </Router>+ </DarkModeContext.Provider>+ ),+ document.getElementById('root')!,+);diff --git a/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx b/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsxindex 4788c6317a..8fea970dea 100644--- a/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx+++ b/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx@@ -409,7 +409,14 @@ export function GuestDrawerOverview(props: GuestDrawerOverviewProps) {};const diskFact = () => {const disk = props.guest.disk;- if (!disk || !((disk.total ?? 0) > 0) || typeof props.currentMetrics?.disk !== 'number') {+ if (+ !disk ||+ !((disk.total ?? 0) > 0) ||+ typeof disk.used !== 'number' ||+ !Number.isFinite(disk.used) ||+ disk.used < 0 ||+ typeof props.currentMetrics?.disk !== 'number'+ ) {return '';}return `${formatBytes(disk.used ?? 0)} of ${formatBytes(disk.total ?? 0)} disk`;diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsxindex 0ef546b08e..1c174006a5 100644--- a/frontend-modern/src/components/Workloads/GuestRow.tsx+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx@@ -80,6 +80,7 @@ export function GuestRow(props: GuestRowProps) {customUrl,diskAnomaly,diskIOEmphasis,+ diskPercent,diskRead,diskThresholds,diskUsageRead,@@ -344,7 +345,7 @@ export function GuestRow(props: GuestRowProps) {});const renderDiskSparkline = () =>renderMetricSparkline('disk', {- valueLabel: () => (hasDiskUsage() ? formatMetricPercent(props.guest.disk?.usage) : '—'),+ valueLabel: () => (hasDiskUsage() ? formatMetricPercent(diskPercent()) : '—'),title: () => `${props.guest.name} disk usage history`,tooltip: () => diskReadStatus()?.message,formatValue: formatMetricPercent,diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsxindex 783bd12592..0deaa7576d 100644--- a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx@@ -92,6 +92,24 @@ const utilization = () => screen.getAllByTestId('guest-history-group-chart')[0];// Actual backend provenance remains authoritative. Removing a VM lock alone// cannot turn retained readings into current data or prove native thaw.describe('GuestDrawerHistory filesystem provenance', () => {+ it('keeps capacity-only aggregates unknown and accepts explicit zero/byte-only fallback without chart points', async () => {+ const fetch = vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(response());+ const [value, setValue] = createSignal<WorkloadGuest>({ ...guest(''), disk: { total: 100 } });+ mount(value);+ await settledHistory();+ expect(utilization().querySelector('[data-history-current="disk"]')).toBeNull();+ setValue({ ...value(), disk: { total: 100, used: 50 } });+ expect(utilization().querySelector('[data-history-current="disk"]')).toHaveTextContent(+ 'Disk50.0%current',+ );+ setValue({ ...value(), disk: { usage: 0 } });+ expect(utilization().querySelector('[data-history-current="disk"]')).toHaveTextContent(+ 'Disk0.0%current',+ );+ expect(utilization().querySelector('path[data-history-series]')).toBeNull();+ expect(fetch).toHaveBeenCalledTimes(1);+ });+it('withdraws the current stopped-VM carrier but keeps real stored History', async () => {const fetch = vi.spyOn(ChartsAPI, 'getMetricsHistory')diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsxindex e48866b09c..bcd8c4e085 100644--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx@@ -2543,6 +2543,45 @@ describe('GuestRow', () => {});describe('disk usage edge cases', () => {+ it.each(['bars', 'sparklines'] as const)(+ 'keeps missing capacity-only reads separate from zero and byte-only reads in %s',+ (mode) => {+ const [value, setValue] = createSignal(makeGuest({ disk: { total: 100 }, disks: [] }));+ const { container } = render(() => (+ <table>+ <tbody>+ <GuestRow+ guest={value()}+ visibleColumnIds={['name', 'disk']}+ metricDisplayMode={mode}+ />+ </tbody>+ </table>+ ));+ const row = container.querySelector('tr');+ const cell = () => container.querySelector('[data-workload-col="disk"]')!;+ expect(screen.queryByTestId('disk-bar')).toBeNull();+ expect(cell()).not.toHaveTextContent('0%');+ setValue({ ...value(), disk: { usage: 1 } });+ if (mode === 'bars') expect(screen.getByTestId('disk-bar')).toBeInTheDocument();+ else+ expect(+ screen.getByRole('img', { name: 'test-vm disk usage history, current 1%' }),+ ).toBeInTheDocument();+ setValue({ ...value(), disk: { used: 50, total: 100 } });+ if (mode === 'sparklines')+ expect(+ screen.getByRole('img', { name: 'test-vm disk usage history, current 50%' }),+ ).toBeInTheDocument();+ setValue({ ...value(), disk: { usage: 0 } });+ if (mode === 'sparklines')+ expect(+ screen.getByRole('img', { name: 'test-vm disk usage history, current 0%' }),+ ).toBeInTheDocument();+ expect(container.querySelector('tr')).toBe(row);+ },+ );+it('shows dash when disk usage is -1 (unsupported)', () => {renderGuestRow({guest: makeGuest({diff --git a/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx b/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsxindex 46929d2fc3..b0ce5c3b73 100644--- a/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx@@ -19,11 +19,13 @@ import { StackedDiskBar } from '../StackedDiskBar';// ── Helpers ──────────────────────────────────────────────────────────────────function makeDisk(overrides: Partial<Disk> = {}): Disk {+ const total = overrides.total ?? 107374182400;+ const used = overrides.used ?? 53687091200;return {total: 107374182400, // 100 GiBused: 53687091200, // ~50 GiBfree: 53687091200,- usage: 50,+ usage: total > 0 ? (used / total) * 100 : 0,mountpoint: '/',type: 'ext4',device: '/dev/sda1',diff --git a/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts b/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.tsindex 158dc85cc9..f9515e2da8 100644--- a/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts+++ b/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts@@ -49,6 +49,22 @@ const makeAnomaly = (overrides: Partial<AnomalyReport> = {}): AnomalyReport => (});describe('stackedDiskBarModel (branch coverage 2)', () => {+ it('does not invent aggregate usage from capacity, or bytes from a percentage', () => {+ const capacity = buildStackedDiskBarPresentation({ aggregateDisk: { total: 100 } }, 400);+ expect(capacity.unavailable).toBe(true);+ expect(capacity.displayLabel).toBe('N/A');+ expect(capacity.tooltipContent[0]).toMatchObject({ percent: '—', used: '?', total: '100 B' });+ const percentage = buildStackedDiskBarPresentation({ aggregateDisk: { usage: 0.5 } }, 400);+ expect(percentage.unavailable).toBe(false);+ expect(percentage.barPercent).toBe(0.5);+ expect(percentage.displaySublabel).toBe('');+ expect(percentage.tooltipContent[0]).toMatchObject({ used: '?', total: '—' });+ // DiskInfo is not an aggregate metric: its genuine zero bytes may be omitted.+ const filesystem = buildStackedDiskBarPresentation({ disks: [{ total: 100, free: 100 }] }, 400);+ expect(filesystem.unavailable).toBe(false);+ expect(filesystem.displayPercentValue).toBe(0);+ });+describe('getDiskUsagePercent (via miniDisks[].percent)', () => {it('uses the used/total ratio when total > 0', () => {// Branch: disk.total > 0 -> (used / total) * 100.@@ -76,7 +92,7 @@ describe('stackedDiskBarModel (branch coverage 2)', () => {);it.each([- { usage: 0.5, expected: 50 },+ { usage: 0.5, expected: 0.5 },{ usage: 75, expected: 75 },{ usage: 0, expected: 0 },])('preserves independently supplied aggregate-only percentages: %j', ({ usage, expected }) => {diff --git a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.tsindex e71d35fdd9..38b0264446 100644--- a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts+++ b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts@@ -575,10 +575,10 @@ describe('workloadSelectors (branch coverage)', () => {});describe('getDiskUsagePercent', () => {- it('treats usage of exactly 1 as a ratio (100) not a percentage', () => {+ it('treats usage of exactly 1 as one percent, not a fraction', () => {expect(getDiskUsagePercent(makeGuest(1, { disk: { total: 100, used: 100, free: 0, usage: 1 } })),- ).toBe(100);+ ).toBe(1);});it('keeps a reported zero but treats negative usage as unavailable', () => {@@ -590,17 +590,19 @@ describe('workloadSelectors (branch coverage)', () => {).toBeNull();});- it('falls back to used/total when usage is non-finite (Infinity)', () => {+ it('rejects an explicitly non-finite percentage, even with retained bytes', () => {expect(getDiskUsagePercent(makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: Infinity } }),),- ).toBe(25);+ ).toBeNull();});it('clamps used/total result above 100 to 100', () => {expect(- getDiskUsagePercent(makeGuest(1, { disk: { total: 100, used: 150, free: 0, usage: NaN } })),+ getDiskUsagePercent(+ makeGuest(1, { disk: { total: 100, used: 150, free: 0, usage: undefined } }),+ ),).toBe(100);});diff --git a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.tsindex cf1c97a4b4..2ab01830e4 100644--- a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts+++ b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts@@ -871,12 +871,12 @@ describe('workloadSelectors', () => {});describe('getDiskUsagePercent', () => {- it('handles ratio and percentage disk usage with clamping', () => {+ it('uses percentage points, including below one, with clamping', () => {expect(getDiskUsagePercent(makeGuest(1, { disk: { total: 100, used: 42, free: 58, usage: 0.42 } }),),- ).toBe(42);+ ).toBe(0.42);expect(getDiskUsagePercent(makeGuest(2, { disk: { total: 100, used: 85, free: 15, usage: 85 } })),).toBe(85);@@ -888,7 +888,7 @@ describe('workloadSelectors', () => {it('falls back to used/total and returns null for invalid inputs', () => {expect(getDiskUsagePercent(- makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: NaN } }),+ makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: undefined } }),),).toBe(25);expect(@@ -1082,6 +1082,19 @@ describe('current guest disk selection', () => {selectedKubernetesContext: null,});+ it.each(['asc', 'desc'] as const)(+ 'sorts sub-one-percent readings consistently with search in %s order',+ (direction) => {+ const measured = [0, 0.5, 1, 40, 95].map((usage, i) => diskGuest(i + 1, usage));+ const unknown = diskGuest(6, 0, { disk: { total: 100 } });+ expect([unknown, ...measured].sort(createWorkloadSortComparator('disk', direction)!)).toEqual(+ [...(direction === 'asc' ? measured : [...measured].reverse()), unknown],+ );+ expect(select([...measured, unknown], 'disk>90')).toEqual([measured[4]]);+ expect(select([...measured, unknown], 'disk<=1')).toEqual(measured.slice(0, 3));+ },+ );+it.each(['prev-vm-locked', 'prev-agent-timeout', 'permission-denied', 'agent-cooldown'])('excludes %s numbers from disk sorting and numeric search without hiding inventory',(diskStatusReason) => {diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.tsindex e2f5632a81..4494e7b495 100644--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts@@ -26,6 +26,7 @@ import {} from '@/utils/workloadGuestPresentation';import { getWorkloadCPUPercent, resolveWorkloadType } from '@/utils/workloads';import { getWorkloadMetricHistoryTarget } from '@/utils/workloadMetricHistoryTarget';+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';import type { NestedWorkloadContext } from './nestedWorkloadContext';import type { WorkloadsMemoryDisplayBasis } from './workloadsFilterModel';@@ -123,8 +124,9 @@ export const getGuestDrawerAlertAttention = (};const getGuestDrawerDiskUsage = (guest: Guest): number | undefined => {- const usage = guest.telemetryAvailability?.disk === false ? undefined : guest.disk?.usage;- return typeof usage === 'number' && Number.isFinite(usage) && usage >= 0 ? usage : undefined;+ return guest.telemetryAvailability?.disk === false+ ? undefined+ : (getWorkloadDiskUsagePercent(guest.disk) ?? undefined);};export type GuestDrawerMemoryReading = MemoryObservationPresentation;diff --git a/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts b/frontend-modern/src/components/Workloads/stackedDiskBarModel.tsindex 85ace33d5f..de4071d2b4 100644--- a/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts+++ b/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts@@ -1,5 +1,6 @@import type { Disk } from '@/types/api';import { getFilesystemByteUsagePercent } from '@/utils/filesystemByteUsage';+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';import type { WorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';import type { AnomalyReport } from '@/types/aiIntelligence';import {@@ -115,11 +116,7 @@ function getDiskUsagePercent(disk: Disk): number {if (total > 0) {return ((disk.used ?? 0) / total) * 100;}- const usage = disk.usage;- if (typeof usage === 'number' && Number.isFinite(usage)) {- return usage <= 1 ? usage * 100 : usage;- }- return 0;+ return getWorkloadDiskUsagePercent(disk) ?? 0;}// Unknown sentinels and invalid/incomplete byte readings cannot contribute@@ -242,17 +239,25 @@ function buildTooltipContent(});}- if (options.aggregateDisk && (options.aggregateDisk.total ?? 0) > 0) {- const percentValue = getDiskUsagePercent(options.aggregateDisk);+ if (options.aggregateDisk) {+ const aggregate = options.aggregateDisk;+ const percentValue = getWorkloadDiskUsagePercent(aggregate);+ const hasUsed =+ typeof aggregate.used === 'number' && Number.isFinite(aggregate.used) && aggregate.used >= 0;+ const hasTotal =+ typeof aggregate.total === 'number' &&+ Number.isFinite(aggregate.total) &&+ aggregate.total > 0;return [{- color: options.current- ? getMetricColorRgba(percentValue, 'disk', options.thresholds)- : UNKNOWN_DISK_COLOR,+ color:+ options.current && percentValue !== null+ ? getMetricColorRgba(percentValue, 'disk', options.thresholds)+ : UNKNOWN_DISK_COLOR,label: 'Total',- percent: options.unavailable ? '—' : formatPercent(percentValue),- total: formatBytes(options.aggregateDisk.total ?? 0),- used: options.unavailable ? '?' : formatBytes(options.aggregateDisk.used ?? 0),+ percent: options.unavailable || percentValue === null ? '—' : formatPercent(percentValue),+ total: hasTotal ? formatBytes(aggregate.total!) : '—',+ used: options.unavailable || !hasUsed ? '?' : formatBytes(aggregate.used!),},];}@@ -289,14 +294,8 @@ export function buildStackedDiskBarPresentation(// Independently supplied aggregate percentages keep their legacy fallback;// they do not make an unmeasured per-filesystem byte row usable.const aggregate = props.aggregateDisk;- const hasAggregateUsage = Boolean(- aggregate &&- (getFilesystemByteUsagePercent(aggregate) !== null ||- ((aggregate.total ?? 0) <= 0 &&- typeof aggregate.usage === 'number' &&- Number.isFinite(aggregate.usage) &&- aggregate.usage >= 0)),- );+ const aggregatePercent = getWorkloadDiskUsagePercent(aggregate);+ const hasAggregateUsage = aggregatePercent !== null;// Retained numbers explain the last report, not live pressure. If every// supplied filesystem is unmeasured, do not fall through to a fabricated 0%.const unavailable =@@ -329,12 +328,11 @@ export function buildStackedDiskBarPresentation(const totalUsed = hasDisks? disks.reduce((sum, disk) => sum + (disk.used || 0), 0): (aggregateDisk?.used ?? 0);- const overallPercent =- totalCapacity > 0- ? (totalUsed / totalCapacity) * 100- : aggregateDisk- ? getDiskUsagePercent(aggregateDisk)- : 0;+ const overallPercent = hasDisks+ ? (totalUsed / totalCapacity) * 100+ : unavailable+ ? 0+ : (aggregatePercent ?? 0);const anomalyRatio = formatAnomalyRatio(anomaly) ?? '';const maxInfo = getMaxDiskInfo(disks);const useMaxSummary =@@ -351,7 +349,15 @@ export function buildStackedDiskBarPresentation(: '';const displayLabel = unavailable ? 'N/A' : formatPercent(displayPercentValue);const displaySublabel =- unavailable || (useMaxSummary && maxInfo)+ unavailable ||+ (useMaxSummary && maxInfo) ||+ (!hasDisks &&+ !(+ typeof aggregateDisk?.used === 'number' &&+ Number.isFinite(aggregateDisk.used) &&+ aggregateDisk.used >= 0 &&+ totalCapacity > 0+ ))? '': `${formatBytes(totalUsed)}/${formatBytes(totalCapacity)}`;const diskCountLabel = hasMultipleDisks ? `${disks.length} disks` : '';diff --git a/frontend-modern/src/components/Workloads/useGuestRowState.ts b/frontend-modern/src/components/Workloads/useGuestRowState.tsindex e50c4aac5b..b70bee5c1c 100644--- a/frontend-modern/src/components/Workloads/useGuestRowState.ts+++ b/frontend-modern/src/components/Workloads/useGuestRowState.ts@@ -10,6 +10,7 @@ import { getGuestHealthIndicator, isGuestRunning } from '@/utils/status';import { formatBytes } from '@/utils/format';import { getContainerRuntimeBadgeForRuntime } from '@/utils/resourceBadgePresentation';import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';import {getCanonicalWorkloadId,getWorkloadPlatformScopes,@@ -215,13 +216,7 @@ export function useGuestRowState(props: GuestRowProps) {return Math.max(0, Math.min(usage, 100));});- const diskPercent = createMemo(() => {- const disk = props.guest.disk;- const total = disk?.total ?? 0;- if (!disk || total === 0) return 0;- if (disk.usage === -1) return -1;- return ((disk.used ?? 0) / total) * 100;- });+ const diskPercent = createMemo(() => getWorkloadDiskUsagePercent(props.guest.disk));// The cell's filesystem bars and aggregate follow the drawer's rule: a// linked agent's filesystems follow that agent, Proxmox's its read reason.@@ -232,14 +227,12 @@ export function useGuestRowState(props: GuestRowProps) {const hasDiskUsage = createMemo(() => {const guest = props.guest;if (!guest.disk || guest.telemetryAvailability?.disk === false) return false;- const total = guest.disk.total ?? 0;- if (!Number.isFinite(total) || total <= 0) return false;// A generic canonical merge can retain the previous numeric metric while// its source reports no usable guest reading. Only a last known reading// may keep that number visible.if (diskUsageRead().state === 'unavailable') return false;const percent = diskPercent();- return Number.isFinite(percent) && percent >= 0;+ return percent !== null;});const parentOnline = createMemo(() => props.parentNodeOnline !== false);diff --git a/frontend-modern/src/components/Workloads/workloadSelectors.ts b/frontend-modern/src/components/Workloads/workloadSelectors.tsindex ba3dc7a497..df9908b99e 100644--- a/frontend-modern/src/components/Workloads/workloadSelectors.ts+++ b/frontend-modern/src/components/Workloads/workloadSelectors.ts@@ -21,7 +21,7 @@ import {workloadMatchesViewMode,} from '@/utils/workloads';import { getWorkloadTypePresentation } from '@/utils/workloadTypePresentation';-import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';+import { getCurrentWorkloadDiskUsage } from '@/utils/workloadDiskUsage';import { getCurrentWorkloadMemoryUsage } from '@/utils/memoryObservation';import {getKubernetesContextKey,@@ -287,36 +287,9 @@ export const filterWorkloads = ({};export const getDiskUsagePercent = (guest: WorkloadGuest): number | null => {- const disk = guest?.disk;// The row may retain a clearly labelled last-known number. It must not// compete with current readings when sorting capacity, in either direction.- if (- !disk ||- guest.telemetryAvailability?.disk === false ||- getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current' ||- (typeof disk.usage === 'number' && disk.usage < 0)- ) {- return null;- }-- const clamp = (value: number) => Math.min(100, Math.max(0, value));-- if (typeof disk.usage === 'number' && Number.isFinite(disk.usage)) {- const usageValue = disk.usage > 1 ? disk.usage : disk.usage * 100;- return clamp(usageValue);- }-- if (- typeof disk.used === 'number' &&- Number.isFinite(disk.used) &&- typeof disk.total === 'number' &&- Number.isFinite(disk.total) &&- disk.total > 0- ) {- return clamp((disk.used / disk.total) * 100);- }-- return null;+ return getCurrentWorkloadDiskUsage(guest);};export const createWorkloadSortComparator = (diff --git a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts b/frontend-modern/src/hooks/__tests__/useWorkloads.test.tsindex af072f8a9c..2ab9d70d1b 100644--- a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts+++ b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts@@ -83,6 +83,67 @@ describe('useWorkloads', () => {resetWorkloadsCacheForTests();});+ it.each(['api', 'snapshot'] as const)(+ 'preserves aggregate disk presence and percentage points through %s refreshes',+ async (transport) => {+ const [snapshot, setSnapshot] = createSignal<Resource[]>([]);+ let dispose = () => {};+ let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;+ createRoot((d) => {+ dispose = d;+ result = useWorkloads(+ () => true,+ transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},+ );+ });+ try {+ await flushAsync();+ for (const [metric, expected] of [+ [{ total: 100 }, null],+ [{ used: 0 }, null],+ [{}, null],+ [{ used: 0, total: 100 }, 0],+ [{ percent: 0 }, 0],+ [{ percent: 0.5 }, 0.5],+ [{ percent: 1 }, 1],+ [{ value: 0.5 }, 0.5],+ [{ used: 50, total: 200 }, 25],+ [{ percent: -1, used: 0, total: 100 }, null],+ [{ percent: Infinity, used: 0, total: 100 }, null],+ ] as const) {+ const raw = { ...sampleResource, metrics: { ...sampleResource.metrics, disk: metric } };+ if (transport === 'api') {+ apiFetchJSONMock.mockResolvedValue({ data: [raw] });+ await result.refetch();+ } else {+ const { percent, value, ...bytes } = metric as {+ percent?: number;+ value?: number;+ total?: number;+ used?: number;+ };+ setSnapshot([+ {+ ...raw,+ lastSeen: Date.parse(raw.lastSeen),+ disk: { ...bytes, current: percent ?? value } as Resource['disk'],+ } as unknown as Resource,+ ]);+ }+ await flushAsync();+ const row = result.workloads()[0];+ expect(row.id).toBe(sampleResource.id);+ expect(row.telemetryAvailability?.disk).toBe(expected !== null);+ expect(getDiskUsagePercent(row)).toBe(expected);+ if (expected === null && !('used' in metric)) expect(row.disk.used).toBeUndefined();+ expect(row.memory.usage).toBe(50);+ }+ } finally {+ dispose();+ }+ },+ );+it.each((['api', 'snapshot'] as const).flatMap((transport) =>(['vm', 'system-container'] as const).map((type) => ({ transport, type })),diff --git a/frontend-modern/src/hooks/useWorkloads.ts b/frontend-modern/src/hooks/useWorkloads.tsindex 84ec52bd19..00ce7ad6d0 100644--- a/frontend-modern/src/hooks/useWorkloads.ts+++ b/frontend-modern/src/hooks/useWorkloads.ts@@ -10,6 +10,7 @@ import {} from '@/utils/sourcePlatforms';import { canonicalDiscoveryResourceType } from '@/utils/discoveryTarget';import { normalizeDiskArray } from '@/utils/format';+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';import {getWorkloadCPUFraction,isDockerManagedAppContainer,@@ -331,6 +332,27 @@ const buildMetric = (metric?: APIMetricValue) => {return { total, used, free, usage };};+const buildDiskMetric = (metric?: APIMetricValue): WorkloadGuest['disk'] => {+ const disk = {+ total: metric?.total,+ used: metric?.used,+ usage: metric?.percent ?? metric?.value,+ };+ return {+ ...disk,+ // Preserve missing/invalid evidence. Capacity-only metrics must not turn+ // into current 0%, but explicitly reported zero and byte-only reads work.+ usage: getWorkloadDiskUsagePercent(disk) ?? disk.usage,+ free:+ typeof disk.total === 'number' &&+ Number.isFinite(disk.total) &&+ typeof disk.used === 'number' &&+ Number.isFinite(disk.used)+ ? Math.max(0, disk.total - disk.used)+ : undefined,+ };+};+const mapNetworkInterfaces = (interfaces?: APINetworkInterface[]) =>interfaces?.map((iface) => ({name: iface.name,@@ -492,7 +514,8 @@ const mapResourceToWorkload = (resource: APIResource): WorkloadGuest | null => {firstFiniteMetricNumber(resource.metrics?.cpu?.percent, resource.metrics?.cpu?.value) ?? 0;const cpuAvailable = hasMetricValue(resource.metrics?.cpu);const memoryAvailable = hasMetricValue(resource.metrics?.memory);- const diskAvailable = hasMetricValue(resource.metrics?.disk);+ const disk = buildDiskMetric(resource.metrics?.disk);+ const diskAvailable = getWorkloadDiskUsagePercent(disk) !== null;const networkIOAvailable =hasMetricValue(resource.metrics?.netIn) || hasMetricValue(resource.metrics?.netOut);const diskIOAvailable =@@ -567,7 +590,7 @@ const mapResourceToWorkload = (resource: APIResource): WorkloadGuest | null => {balloon: resource.proxmox?.balloon ?? 0,};})(),- disk: buildMetric(resource.metrics?.disk),+ disk,disks: normalizeDiskArray(resource.proxmox?.disks ?? resource.agent?.disks),disksFromAgent: (resource.proxmox?.disks == null && resource.agent?.disks != null) || undefined,// Both the API and owning platform snapshot pass through this mapper.diff --git a/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.ts b/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.tsnew file mode 100644index 0000000000..4b22cfd55e--- /dev/null+++ b/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.ts@@ -0,0 +1,41 @@+import { describe, expect, it } from 'vitest';+import type { Disk } from '@/types/api';+import { getWorkloadDiskUsagePercent } from '../workloadDiskUsage';++describe('workload aggregate disk evidence', () => {+ it.each([0, 0.01, 0.5, 1, 1.01, 40, 95])(+ 'keeps %s percentage points without guessing a fraction',+ (usage) => {+ expect(getWorkloadDiskUsagePercent({ usage })).toBe(usage);+ expect(getWorkloadDiskUsagePercent({ usage, total: 100 })).toBe(usage);+ },+ );++ it.each([+ undefined,+ null,+ {},+ { total: 100 },+ { free: 100 },+ { used: 0 },+ { used: 0, total: 0 },+ { used: -1, total: 100 },+ { used: NaN, total: 100 },+ { used: 0, total: Infinity },+ { used: 0, total: -1 },+ ...[-1, NaN, Infinity].map((usage) => ({ usage, total: 100, used: 0 })),+ ] satisfies Array<Disk | undefined | null>)(+ 'does not manufacture a healthy zero from %j',+ (disk) => {+ expect(getWorkloadDiskUsagePercent(disk)).toBeNull();+ },+ );++ it('uses finite byte readings only when no percentage is supplied', () => {+ expect(getWorkloadDiskUsagePercent({ used: 0, total: 100 })).toBe(0);+ expect(getWorkloadDiskUsagePercent({ used: 0.5, total: 100 })).toBe(0.5);+ expect(getWorkloadDiskUsagePercent({ used: 50, total: 200 })).toBe(25);+ expect(getWorkloadDiskUsagePercent({ used: 50, total: 200, usage: 20 })).toBe(20);+ expect(getWorkloadDiskUsagePercent({ used: 150, total: 100 })).toBe(100);+ });+});diff --git a/frontend-modern/src/utils/searchQuery.ts b/frontend-modern/src/utils/searchQuery.tsindex f2efb42438..8bf5ffa047 100644--- a/frontend-modern/src/utils/searchQuery.ts+++ b/frontend-modern/src/utils/searchQuery.ts@@ -1,6 +1,6 @@import type { WorkloadGuest } from '@/types/workloads';-import { getWorkloadCPUPercent, resolveWorkloadType } from '@/utils/workloads';-import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';+import { getWorkloadCPUPercent } from '@/utils/workloads';+import { getCurrentWorkloadDiskUsage } from '@/utils/workloadDiskUsage';import { getCurrentWorkloadMemoryUsage } from '@/utils/memoryObservation';// Exclusion-aware split of a free-text search. Terms prefixed with `-` hide@@ -166,14 +166,8 @@ function evaluateMetricCondition(guest: FilterableItem, condition: MetricConditicase 'disk': {// Missing and retained reads are not zero (or current capacity).// Preserve the same provider/linked-agent freshness rule as the row.- if (- guest.telemetryAvailability?.disk === false ||- getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current'- ) {- return false;- }- const usage = guest.disk?.usage;- if (typeof usage !== 'number' || !Number.isFinite(usage) || usage < 0) return false;+ const usage = getCurrentWorkloadDiskUsage(guest);+ if (usage === null) return false;value = usage;break;}diff --git a/frontend-modern/src/utils/workloadDiskUsage.ts b/frontend-modern/src/utils/workloadDiskUsage.tsnew file mode 100644index 0000000000..f4e7d16df1--- /dev/null+++ b/frontend-modern/src/utils/workloadDiskUsage.ts@@ -0,0 +1,36 @@+import type { Disk } from '@/types/api';+import type { WorkloadGuest } from '@/types/workloads';+import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';+import { resolveWorkloadType } from '@/utils/workloads';++// Workload aggregate metrics use percentages, including values below 1%.+// Unlike DiskInfo filesystem entries (whose zero bytes are omitted on the+// wire), an aggregate capacity alone is not an observed usage measurement.+export const getWorkloadDiskUsagePercent = (disk?: Disk | null): number | null => {+ if (!disk) return null;+ if (disk.usage !== undefined) {+ return typeof disk.usage === 'number' && Number.isFinite(disk.usage) && disk.usage >= 0+ ? Math.min(100, disk.usage)+ : null;+ }+ const { used, total } = disk;+ if (+ typeof used !== 'number' ||+ !Number.isFinite(used) ||+ used < 0 ||+ typeof total !== 'number' ||+ !Number.isFinite(total) ||+ total <= 0+ ) {+ return null;+ }+ const percent = (used / total) * 100;+ return Number.isFinite(percent) ? Math.min(100, percent) : null;+};++export const getCurrentWorkloadDiskUsage = (guest: WorkloadGuest): number | null =>+ !guest ||+ guest.telemetryAvailability?.disk === false ||+ getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current'+ ? null+ : getWorkloadDiskUsagePercent(guest.disk);