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 guest memory alerts bound to their observations
pulse-triage[bot]96f73b8dd75c
diff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex f6166a195b..62bc1e369d 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,31 @@## Purpose+### Guest memory alerts do not translate unrelated samples (12 October 2026)++When the Workloads row uses host-relative memory, its existing guest drawer+explains that alert percentages use guest allocation while the row uses host+capacity. The alert retains its own message, evaluated value, observation time,+clear rule and hover evidence. The basis explanation is visible detail, not a+percentage calculated from the guest's latest bytes and the host's latest+capacity: even current values need not describe the alert's observation, and+retained or unavailable values must not acquire authority from a poll refresh.++Guest-relative rows and non-memory alerts keep their existing attention copy.+The row's own memory calculations, observation qualification and accepted zero,+collection and threshold evaluation remain unchanged. This does not establish+native recovery, ordinary notification delivery or released availability.++`guestDrawerAlertMemoryBasis.test.ts` covers current/retained/unavailable/unknown+observations, independent host capacity and alert-owned evaluation phases.+`GuestDrawerOverview.alertMemoryBasis.test.tsx` covers same-guest updates and+basis selection in the mounted production attention panel; `GuestDrawer.test.tsx`+retains the connected full-drawer regression. The desktop/phone production+fixture `browser-tests/guest-alert-memory-basis.cjs` also exercises the row and+native basis selector. Browser acceptance must be recorded separately; adding+the fixture does not establish a passing browser run.++### Workloads node attribution preserves instance/node boundariesWorkloads uses an encoded instance/node tuple for UI node scopes, grouping anddiff --git a/frontend-modern/browser-tests/guest-alert-memory-basis.cjs b/frontend-modern/browser-tests/guest-alert-memory-basis.cjsnew file mode 100644index 0000000000..9b96fde5e1--- /dev/null+++ b/frontend-modern/browser-tests/guest-alert-memory-basis.cjs@@ -0,0 +1,322 @@+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 original = process.argv.includes('--original');+const root = '/workspace/frontend-modern';+const output = `/workspace/tmp/guest-alert-memory-basis/browser-${original ? 'original' : 'final'}`;+const origin = 'http://127.0.0.1:5344';+const basisNote = 'Alert percentages use guest allocation. The table row uses host capacity.';+const runtime = [+ 'frontend-modern/src/components/Workloads/guestDrawerModel.ts',+ 'frontend-modern/src/components/Workloads/GuestDrawer.tsx',+ 'frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx',+ 'frontend-modern/src/components/Workloads/GuestRow.tsx',+ 'frontend-modern/src/features/alerts/metricAlertPresentation.ts',+ 'frontend-modern/src/utils/memoryObservation.ts',+];+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');+const settle = (page) =>+ page.evaluate(async () => {+ await document.fonts.ready;+ await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));+ });++(async () => {+ 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 guest row/drawer, alert presentation and CSS; synthetic observations/local GET replies. No guest command, installed recovery, notification delivery, reporter 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/guest-alert-memory-basis.html'] },+ server: { host: '127.0.0.1', port: 5344, 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);+ 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() });+ return route.fulfill({+ json: {+ success: true,+ data: [],+ available: false,+ alerts: [],+ config: null,+ capabilities: [],+ relationships: [],+ anomalies: [],+ count: 0,+ },+ });+ });+ await page.addInitScript((isDark) => {+ document.addEventListener('DOMContentLoaded', () =>+ document.documentElement.classList.toggle('dark', isDark),+ );+ }, dark);+ await page.goto(`${origin}/browser-tests/guest-alert-memory-basis.html`, {+ waitUntil: 'domcontentloaded',+ timeout: 60000,+ });+ const row = page.locator('[data-guest-id]');+ await row.waitFor({ timeout: 60000 });+ // Keyboard on desktop and a real tap on the phone use the production row opener.+ const opener = row.getByRole('button', { name: 'Expand memory-guest', exact: true });+ if (width < 768) await row.tap();+ else {+ await opener.focus();+ await page.keyboard.press('Enter');+ }+ const attention = page.getByTestId('drawer-attention-section');+ await attention.waitFor();+ const snapshot = async (state) => {+ await settle(page);+ const text = await attention.innerText();+ record.states.push({+ state,+ alert: text,+ row_memory: await row.locator('[data-workload-col="memory"]').innerText(),+ });+ return text;+ };+ const capture = async (state) => {+ await settle(page);+ const file = `${output}/${name}-${state}.png`;+ await page.screenshot({ path: file, fullPage: true });+ result.screenshots.push({ path: file, sha256: hash(file), state });+ };+ const verifyBasis = async (state) => {+ const text = await snapshot(state);+ if (original) {+ assert.match(text, /VM memory at 86\.6% \(guest allocation · 13% of host capacity\)/);+ assert.equal(text.includes(basisNote), false);+ } else {+ assert.match(text, /VM memory at 86\.6%/);+ assert.ok(text.includes(basisNote));+ assert.doesNotMatch(text, /\d+% of host capacity/);+ }+ record.checks.push(state);+ };+ await verifyBasis('retained-memory');+ assert.match(+ await row.locator('[data-workload-col="memory"]').innerText(),+ /Last known|Prior/,+ );+ await capture('retained');+ await page.evaluate(() => {+ const fixture = window.__guestAlertMemory;+ fixture.apply({+ memory: {+ ...fixture.guest().memory,+ usageUnavailable: true,+ observation: { state: 'unavailable', source: 'guest-agent-meminfo' },+ },+ });+ });+ await verifyBasis('unavailable-memory');+ assert.match(+ await row.locator('[data-workload-col="memory"]').innerText(),+ /Unavailable|N\/A/,+ );+ await capture('unavailable');+ if (!original) {+ await page.evaluate(() => {+ const fixture = window.__guestAlertMemory;+ fixture.apply({+ memory: {+ ...fixture.guest().memory,+ usageUnavailable: false,+ observation: {+ state: 'current',+ source: 'agent',+ observedAt: new Date().toISOString(),+ },+ },+ });+ });+ await verifyBasis('current-sample-differs-from-alert');+ assert.match(await row.locator('[data-workload-col="memory"]').innerText(), /13%/);+ await page.evaluate(() => {+ const fixture = window.__guestAlertMemory;+ const memoryAlert = {+ ...fixture.alert,+ metricStatus: {+ phase: 'latched',+ value: 72,+ unit: '%',+ observedAt: new Date().toISOString(),+ trigger: 85,+ recovery: 70,+ },+ };+ fixture.alerts([+ memoryAlert,+ {+ ...fixture.alert,+ id: 'cpu-control',+ type: 'cpu',+ message: 'CPU event stays unchanged',+ value: 92,+ threshold: 80,+ },+ ]);+ });+ const live = await snapshot('alert-owned-live-status-and-cpu-control');+ assert.match(live, /Memory 72% now, back under the 85% alert level/);+ assert.match(live, /Stays open until it reaches 70% or lower\./);+ assert.equal(live.split(basisNote).length - 1, 1);+ assert.match(live, /CPU event stays unchanged/);+ assert.doesNotMatch(live, /\d+% of host capacity/);+ record.checks.push('live-alert-reading-clear-rule-and-cpu-unchanged');+ await capture('live-alert');+ // Use the native select, and return using keyboard, not a synthetic change event.+ await page.getByLabel('Memory basis').selectOption('guest');+ await settle(page);+ assert.equal((await attention.innerText()).includes(basisNote), false);+ // The existing AnimatedNumber eases basis changes over several frames.+ // Wait for the observable final value rather than sampling a mid-frame number.+ await page.waitForFunction(+ () =>+ document.querySelector('[data-workload-col="memory"] [data-animated-number]')+ ?.textContent === '25%',+ );+ assert.match(await row.locator('[data-workload-col="memory"]').innerText(), /25%/);+ await snapshot('guest-basis-final-value');+ await capture('guest-basis');+ await page.getByLabel('Memory basis').focus();+ await page.keyboard.press('ArrowDown');+ await page.keyboard.press('Enter');+ await settle(page);+ assert.ok((await attention.innerText()).includes(basisNote));+ assert.equal(await page.getByLabel('Memory basis').inputValue(), 'host');+ await page.waitForFunction(+ () =>+ document.querySelector('[data-workload-col="memory"] [data-animated-number]')+ ?.textContent === '13%',+ );+ await snapshot('host-basis-final-value');+ record.checks.push('basis-select-preserves-guest-and-host-row-calculation');+ await page.evaluate(() => {+ const fixture = window.__guestAlertMemory;+ fixture.apply(+ {+ memory: {+ total: 4 * 1024 ** 3,+ used: 0,+ free: 4 * 1024 ** 3,+ usage: 0,+ observation: {+ state: 'current',+ source: 'agent',+ observedAt: new Date().toISOString(),+ },+ },+ },+ 0,+ );+ });+ await settle(page);+ assert.ok((await attention.innerText()).includes(basisNote));+ assert.doesNotMatch(await attention.innerText(), /\d+% of host capacity/);+ record.checks.push('zero-and-missing-host-capacity-do-not-rewrite-alert');+ }+ const geometry = await page.evaluate(() => ({+ width: document.documentElement.clientWidth,+ scrollWidth: document.documentElement.scrollWidth,+ }));+ assert.ok(geometry.scrollWidth <= geometry.width + 1, JSON.stringify(geometry));+ record.checks.push('no-page-overflow-or-errors');+ assert.deepEqual(record.errors, []);+ assert.equal(+ record.requests.some((request) => request.blocked || request.method !== 'GET'),+ false,+ );+ await browser.close();+ browser = null;+ }+ result.cleanup.browsers = true;+ result.result = original ? 'adverse-reproduced' : 'passed';+ } catch (error) {+ result.error = error.message;+ throw error;+ } finally {+ if (browser) {+ await browser.close();+ result.cleanup.browsers = true;+ }+ await server.close();+ result.cleanup.server = true;+ fs.writeFileSync(output + '/result.json', JSON.stringify(result, null, 2) + '\n');+ console.log(+ JSON.stringify({+ result: result.result,+ cases: result.cases.length,+ checks: result.cases.reduce((sum, item) => sum + item.checks.length, 0),+ captures: result.screenshots.length,+ cleanup: result.cleanup,+ }),+ );+ }+})().catch((error) => {+ console.error(error);+ process.exitCode = 1;+});diff --git a/frontend-modern/browser-tests/guest-alert-memory-basis.html b/frontend-modern/browser-tests/guest-alert-memory-basis.htmlnew file mode 100644index 0000000000..cbc622fd62--- /dev/null+++ b/frontend-modern/browser-tests/guest-alert-memory-basis.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>Guest alert memory basis evidence</title>+ </head>+ <body>+ <div id="root"></div>+ <script type="module" src="/browser-tests/guest-alert-memory-basis.tsx"></script>+ </body>+</html>diff --git a/frontend-modern/browser-tests/guest-alert-memory-basis.tsx b/frontend-modern/browser-tests/guest-alert-memory-basis.tsxnew file mode 100644index 0000000000..e38cd82ab0--- /dev/null+++ b/frontend-modern/browser-tests/guest-alert-memory-basis.tsx@@ -0,0 +1,160 @@+// Production guest row, drawer, alert presentation and CSS; synthetic observations only.+import { createSignal, Show } from 'solid-js';+import { render } from 'solid-js/web';+import { Route, Router } from '@solidjs/router';+import { GuestRow } from '../src/components/Workloads/GuestRow';+import { GuestDrawer } from '../src/components/Workloads/GuestDrawer';+import {+ getGuestColumnStyle,+ getWorkloadTableLayoutModeForContainer,+} from '../src/components/Workloads/guestRowModel';+import { DarkModeContext } from '../src/contexts/appRuntime';+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';+import type { Alert } from '../src/types/api';+import type { WorkloadGuest } from '../src/types/workloads';+import '../src/index.css';++syncAIRuntimeSettings({ discovery_enabled: false });+const capacity = 4 * 1024 ** 3;+const alert: Alert = {+ id: 'fixture-memory-alert',+ resourceId: 'fixture:pve:101',+ resourceName: 'memory-guest',+ node: 'pve',+ instance: 'fixture',+ type: 'memory',+ level: 'warning',+ message: 'VM memory at 86.6%',+ value: 86.6,+ threshold: 85,+ startTime: new Date(Date.now() - 3600000).toISOString(),+ acknowledged: false,+};+const initial: WorkloadGuest = {+ id: 'fixture:pve:101',+ vmid: 101,+ name: 'memory-guest',+ instance: 'fixture',+ node: 'pve',+ type: 'qemu',+ workloadType: 'vm',+ platformScopes: ['proxmox-pve'],+ platformType: 'proxmox-pve',+ status: 'running',+ cpu: 0.1,+ cpus: 2,+ memory: {+ total: capacity,+ used: capacity / 4,+ free: (capacity * 3) / 4,+ usage: 25,+ observation: {+ state: 'last-known',+ source: 'guest-agent-meminfo',+ observedAt: new Date(Date.now() - 1800000).toISOString(),+ },+ },+ disk: { total: capacity, used: capacity / 2, usage: 50 },+ diskStatusReason: 'prev-vm-locked',+ lock: 'backup',+ guestAgentStatus: 'deferred',+ guestAgentExpected: true,+ networkIn: 10,+ networkOut: 20,+ diskRead: 30,+ diskWrite: 40,+ uptime: 3600,+ template: false,+ lastBackup: 0,+ tags: [],+ lastSeen: new Date().toISOString(),+};++function Fixture() {+ const [guest, setGuest] = createSignal(initial);+ const [alerts, setAlerts] = createSignal([alert]);+ const [basis, setBasis] = createSignal<'guest' | 'host'>('host');+ const [hostTotal, setHostTotal] = createSignal(capacity * 2);+ const [expanded, setExpanded] = createSignal(false);+ const columns = ['name', 'cpu', 'memory', 'disk', 'uptime'];+ const layout = getWorkloadTableLayoutModeForContainer(Math.min(window.innerWidth, 896) - 40);+ Object.assign(window, {+ __guestAlertMemory: {+ apply: (next: Partial<WorkloadGuest>, nextHostTotal?: number) => {+ setGuest((previous) => ({ ...previous, ...next }));+ if (nextHostTotal !== undefined) setHostTotal(nextHostTotal);+ },+ alerts: setAlerts,+ guest,+ alert,+ },+ });+ return (+ <main class="mx-auto min-h-screen max-w-4xl space-y-3 bg-surface p-3 text-base-content">+ <h1 class="text-base font-semibold">Guest alert memory basis</h1>+ <p class="text-xs text-muted">Synthetic observations. No guest or recovery operation.</p>+ <label class="flex gap-2 items-center text-xs">+ Memory basis+ <select+ aria-label="Memory basis"+ class="rounded-sm border border-border bg-surface p-1"+ value={basis()}+ onChange={(e) => setBasis(e.currentTarget.value as 'guest' | 'host')}+ >+ <option value="guest">Guest allocation</option>+ <option value="host">Host capacity</option>+ </select>+ </label>+ <section aria-label="Production guest table">+ <table class="w-full table-fixed" style="border-collapse: separate; border-spacing: 0 4px">+ <colgroup>+ {columns.map((column) => (+ <col style={getGuestColumnStyle(column, window.innerWidth < 768, layout, columns)} />+ ))}+ </colgroup>+ <tbody>+ <GuestRow+ guest={guest()}+ visibleColumnIds={columns}+ memoryDisplayBasis={basis()}+ parentMemoryTotal={hostTotal()}+ parentNodeName="pve"+ workloadTableLayoutMode={layout}+ isExpanded={expanded()}+ onClick={() => setExpanded(!expanded())}+ />+ </tbody>+ </table>+ </section>+ <Show when={expanded()}>+ <section aria-label="Guest details">+ <GuestDrawer+ guest={guest()}+ memoryDisplayBasis={basis()}+ parentMemoryTotal={hostTotal()}+ alerts={alerts()}+ onClose={() => setExpanded(false)}+ />+ </section>+ </Show>+ </main>+ );+}++render(+ () => (+ <Router>+ <Route+ path="*"+ component={() => (+ <DarkModeContext.Provider+ value={() => document.documentElement.classList.contains('dark')}+ >+ <Fixture />+ </DarkModeContext.Provider>+ )}+ />+ </Router>+ ),+ document.getElementById('root')!,+);diff --git a/frontend-modern/browser-verification/3c3a60a153a0a6a9.json b/frontend-modern/browser-verification/3c3a60a153a0a6a9.jsonnew file mode 100644index 0000000000..dec6e49176--- /dev/null+++ b/frontend-modern/browser-verification/3c3a60a153a0a6a9.json@@ -0,0 +1,110 @@+{+ "version": 1,+ "base_sha": "c104d52111fc89ef03b987d27a969338ead24e52",+ "verified_at": "2026-10-12T06:08:06Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts": "1b2cd2cfa12e2b41e071bd566f21fedc4c100d20cf64a2df6ce5941ba24cf4e3"+ },+ "routes": [+ "Workloads guest row -> existing guest drawer / Overview / Needs attention (production components in local fixture)"+ ],+ "states": [+ "Retained guest memory, unavailable usage and a current reading unlike the alert: own 86.6% remains unchanged, separate visible basis explanation, no unrelated host percentage",+ "Alert-owned live 72% and 85% trigger, existing 70% clear rule, CPU control unchanged",+ "Guest/host basis selection preserves final row calculations 25%/13%, with no basis note in guest mode",+ "Accepted current zero with missing host capacity cannot rewrite alert evidence",+ "Light desktop and dark phone: no page overflow, no page errors, only local GET API fixtures"+ ],+ "interactions": [+ "Desktop production disclosure focused and opened with Enter",+ "Phone production row opened by touch",+ "Native basis select -> guest, keyboard ArrowDown/Enter -> host; waited for existing 320ms AnimatedNumber final values",+ "Same mounted guest receives synthetic memory/alert/capacity updates without remounting or guest commands"+ ],+ "viewports": [+ {+ "width": 1280,+ "height": 900,+ "browser": "141.0.7390.37",+ "name": "chromium-desktop-light"+ },+ {+ "width": 390,+ "height": 844,+ "browser": "26.0",+ "name": "webkit-phone-dark"+ }+ ],+ "evidence": {+ "command": "pulse-worker-browser frontend-modern/browser-tests/guest-alert-memory-basis.cjs",+ "playwright": "1.56.1",+ "integration_lock_version": "1.56.1",+ "completed_checks": 14,+ "fixture_sha256": {+ "frontend-modern/browser-tests/guest-alert-memory-basis.cjs": "60ed7baf4655d6ef6c8bd22861c34656afc9179ba7319cc399d2721a495b8fa4",+ "frontend-modern/browser-tests/guest-alert-memory-basis.html": "2fcc8143faae35fc7089bebc175d2db21602acdefc88cff4541a96ad731df580",+ "frontend-modern/browser-tests/guest-alert-memory-basis.tsx": "b5636592102b26918702f86e6ddbd84f59e335a5854a423c1c661f50c9be134c"+ },+ "runtime_sha256": {+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts": "1b2cd2cfa12e2b41e071bd566f21fedc4c100d20cf64a2df6ce5941ba24cf4e3",+ "frontend-modern/src/components/Workloads/GuestDrawer.tsx": "604deee9674aa3d97e45ccf7bc5b8c5dda27017dee2f235c107750911d2981b7",+ "frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx": "606c8b9ba04b171dd21a94968e07ab0ad5e04205e9d4c11791529898d12684b8",+ "frontend-modern/src/components/Workloads/GuestRow.tsx": "b0074114ab442df633b24008fbb5eaebb7bb4a8ad3fc9e0ba0e7d139951b76fb",+ "frontend-modern/src/features/alerts/metricAlertPresentation.ts": "69a853de4a91ccf56ec693b843450488c64a0684712567835a0d09f5a283db28",+ "frontend-modern/src/utils/memoryObservation.ts": "73d7c187a92141a8eb757cb9f09c091351ea78b6381a0cc87a0d9da0877dd01f"+ },+ "captures": [+ {+ "name": "chromium-desktop-light-retained.png",+ "sha256": "52f3c1e321861a83e7cd549204448646933fce3adc04544534883372adf539b4",+ "viewed": true+ },+ {+ "name": "chromium-desktop-light-unavailable.png",+ "sha256": "39dca441ff6a9a64c3ec98b40bda9c9b0a6f45dc531aace02b02c91a8a2e961b",+ "viewed": true+ },+ {+ "name": "chromium-desktop-light-live-alert.png",+ "sha256": "38c6d5d890e7aed5a91f9a3bf89dde44047c2cc1ad9cc21d9818464291e49786",+ "viewed": true+ },+ {+ "name": "chromium-desktop-light-guest-basis.png",+ "sha256": "367da1013bed00d909f64f432d799f9618f78387d123bafb8eef927a99e744e1",+ "viewed": true+ },+ {+ "name": "webkit-phone-dark-retained.png",+ "sha256": "14c34090992f07dc3a47950b4ce58802c2a3b840103f90ce721e1dbe5137f8d2",+ "viewed": true+ },+ {+ "name": "webkit-phone-dark-unavailable.png",+ "sha256": "3dd001fc0b85ff327a6711162f0495f1a3e58dd9f79bd6fbf4beb05e5e1e933e",+ "viewed": true+ },+ {+ "name": "webkit-phone-dark-live-alert.png",+ "sha256": "7a08705e7483513f8d78fbe1b76dd416f4477441ebb34a6ddb4fef3abb9d8370",+ "viewed": true+ },+ {+ "name": "webkit-phone-dark-guest-basis.png",+ "sha256": "922d0022cb3ded040fced1d8db2872b46c69752301e895e5671c37e59d330ef0",+ "viewed": true+ }+ ],+ "cleanup": {+ "browsers": true,+ "server": true+ },+ "result_sha256": "4455ca89fedb7b16c4c555a38584ee5d7ab97f18448f5fc83d29e6699993a0bf",+ "prior_attempt": "First attempt failed after four desktop alert checks because it asserted final 25% during the existing number animation (observed 16%). Fixture waits for final displayed value; no runtime, animation, deadline or threshold change."+ },+ "limits": "Production row/drawer/presentation/CSS with synthetic observations and local GET replies. No guest command, native recovery, ordinary notification delivery, reporter confirmation or released availability."+}diff --git a/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx b/frontend-modern/src/components/Workloads/GuestDrawer.test.tsxindex 7b3ce1a7d3..50bb0830b0 100644--- a/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx+++ b/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx@@ -538,7 +538,7 @@ describe('GuestDrawer', () => {expect(screen.queryByTestId('guest-manage-tab')).not.toBeInTheDocument();});- it('reconciles a guest-allocation memory alert with the host-relative row value', () => {+ it('explains guest-allocation alerts without translating them from another memory sample', () => {solidRender(() => (<GuestDrawerguest={makeGuest({@@ -571,9 +571,13 @@ describe('GuestDrawer', () => {/>));+ expect(screen.getByText('VM memory at 86.6%')).toBeInTheDocument();expect(- screen.getByText('VM memory at 86.6% (guest allocation · 16% of host capacity)'),+ screen.getByText('Alert percentages use guest allocation. The table row uses host capacity.'),).toBeInTheDocument();+ expect(screen.getByTestId('drawer-attention-section')).not.toHaveTextContent(+ '16% of host capacity',+ );});it('leads with the live reading when an open alert holds below its trigger', () => {diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerOverview.alertMemoryBasis.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerOverview.alertMemoryBasis.test.tsxnew file mode 100644index 0000000000..7f9e0e49f3--- /dev/null+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerOverview.alertMemoryBasis.test.tsx@@ -0,0 +1,142 @@+import { cleanup, render, screen } from '@solidjs/testing-library';+import { createSignal, type ComponentProps } from 'solid-js';+import { afterEach, describe, expect, it, vi } from 'vitest';+import type { Alert } from '@/types/api';+import type { WorkloadGuest } from '@/types/workloads';+import { GuestDrawerOverview } from '../GuestDrawerOverview';++vi.mock('../GuestPhysicalDisks', () => ({ GuestPhysicalDisks: () => null }));+afterEach(cleanup);+const at = '2026-10-12T05:00:00Z';+const note = 'Alert percentages use guest allocation. The table row uses host capacity.';+const alert: Alert = {+ id: 'memory-alert',+ resourceId: 'lab:pve:101',+ resourceName: 'memory-guest',+ node: 'pve',+ instance: 'lab',+ type: 'memory',+ level: 'warning',+ message: 'VM memory at 86.6%',+ value: 86.6,+ threshold: 85,+ startTime: at,+ acknowledged: false,+};+const guest = (): WorkloadGuest => ({+ id: 'lab:pve:101',+ vmid: 101,+ name: 'memory-guest',+ node: 'pve',+ instance: 'lab',+ type: 'qemu',+ status: 'running',+ cpu: 0.1,+ cpus: 2,+ memory: {+ total: 4 * 1024 ** 3,+ used: 1024 ** 3,+ free: 3 * 1024 ** 3,+ usage: 25,+ observation: { state: 'current', source: 'agent', observedAt: at },+ },+ disk: { total: 1024, used: 512, usage: 50 },+ networkIn: 0,+ networkOut: 0,+ diskRead: 0,+ diskWrite: 0,+ uptime: 3600,+ template: false,+ lastBackup: 0,+ tags: [],+ lock: '',+ lastSeen: at,+});+const props = (value: WorkloadGuest): ComponentProps<typeof GuestDrawerOverview> => ({+ guest: value,+ guestOsSummary: 'Linux',+ agentHeading: 'Guest agent',+ agentLabel: '',+ agentTitle: '',+ hasAgentInfo: false,+ hasFilesystemDetails: false,+ hasNetworkInterfaces: false,+ hasOsInfo: true,+ hasWorkloadActionAgent: false,+ showInGuestAgentInstallCue: false,+ ipAddresses: [],+ networkInterfaces: [],+ normalizedTags: [],+ backupPresentation: null,+ workloadActionAgentTitle: '',+});++describe('mounted guest drawer alert memory basis', () => {+ it('keeps alert-owned evidence when same-guest memory and capacity change independently', () => {+ const [value, setValue] = createSignal(guest());+ const [hostTotal, setHostTotal] = createSignal(8 * 1024 ** 3);+ const [basis, setBasis] = createSignal<'host' | 'guest'>('host');+ render(() => (+ <GuestDrawerOverview+ {...props(value())}+ parentMemoryTotal={hostTotal()}+ memoryDisplayBasis={basis()}+ alerts={[alert]}+ />+ ));+ const attention = screen.getByTestId('drawer-attention-section');+ expect(screen.getByText(alert.message)).toBeInTheDocument();+ expect(attention).toHaveTextContent(note);+ expect(attention).not.toHaveTextContent('13% of host capacity');+ for (const state of ['last-known', 'unavailable']) {+ setValue({+ ...value(),+ lastSeen: '2026-10-12T06:00:00Z',+ memory: {+ ...value().memory,+ used: 3 * 1024 ** 3,+ usage: 75,+ observation: { state, source: 'agent', observedAt: at },+ },+ });+ setHostTotal(16 * 1024 ** 3);+ expect(screen.getByText(alert.message)).toBeInTheDocument();+ expect(attention).toHaveTextContent(note);+ expect(attention).not.toHaveTextContent('19% of host capacity');+ }+ expect(screen.getByText('Memory reading').closest('tr')).toHaveTextContent('Unavailable');+ setBasis('guest');+ expect(attention).not.toHaveTextContent(note);+ expect(screen.getByText(alert.message)).toBeInTheDocument();+ setBasis('host');+ expect(attention).toHaveTextContent(note);+ });++ it('keeps live alert and clear-rule evidence separate from the row basis', () => {+ const evaluated: Alert = {+ ...alert,+ metricStatus: {+ phase: 'latched',+ value: 72,+ unit: '%',+ observedAt: new Date().toISOString(),+ trigger: 85,+ recovery: 70,+ },+ };+ const cpu = { ...alert, id: 'cpu-alert', type: 'cpu', message: 'CPU event stays unchanged' };+ render(() => (+ <GuestDrawerOverview+ {...props(guest())}+ parentMemoryTotal={8 * 1024 ** 3}+ memoryDisplayBasis="host"+ alerts={[evaluated, cpu]}+ />+ ));+ const attention = screen.getByTestId('drawer-attention-section');+ expect(attention).toHaveTextContent('Memory 72% now, back under the 85% alert level');+ expect(attention).toHaveTextContent(`Stays open until it reaches 70% or lower. ${note}`);+ expect(screen.getByText('CPU event stays unchanged')).toBeInTheDocument();+ expect(attention.textContent?.split(note)).toHaveLength(2);+ });+});diff --git a/frontend-modern/src/components/Workloads/__tests__/guestDrawerAlertMemoryBasis.test.ts b/frontend-modern/src/components/Workloads/__tests__/guestDrawerAlertMemoryBasis.test.tsnew file mode 100644index 0000000000..97ccac8922--- /dev/null+++ b/frontend-modern/src/components/Workloads/__tests__/guestDrawerAlertMemoryBasis.test.ts@@ -0,0 +1,164 @@+import { describe, expect, it } from 'vitest';+import type { Alert } from '@/types/api';+import type { WorkloadGuest } from '@/types/workloads';+import { getAlertAttentionCopy } from '@/features/alerts/metricAlertPresentation';+import { getGuestDrawerAlertAttention } from '../guestDrawerModel';++const at = '2026-10-12T05:00:00Z';+const now = () => Date.parse(at);+const note = 'Alert percentages use guest allocation. The table row uses host capacity.';+const alert: Alert = {+ id: 'memory-alert',+ resourceId: 'lab:pve:101',+ resourceName: 'memory-guest',+ node: 'pve',+ instance: 'lab',+ type: 'memory',+ level: 'warning',+ message: 'VM memory at 86.6%',+ value: 86.6,+ threshold: 85,+ startTime: at,+ acknowledged: false,+};+const guest = (state?: string): WorkloadGuest => ({+ id: 'lab:pve:101',+ vmid: 101,+ name: 'memory-guest',+ node: 'pve',+ instance: 'lab',+ status: 'running',+ type: 'qemu',+ cpu: 0.1,+ cpus: 2,+ memory: {+ total: 4 * 1024 ** 3,+ used: 1024 ** 3,+ free: 3 * 1024 ** 3,+ usage: 25,+ ...(state ? { observation: { state, source: 'agent', observedAt: at } } : {}),+ },+ disk: { total: 1024, used: 512, usage: 50 },+ networkIn: 0,+ networkOut: 0,+ diskRead: 0,+ diskWrite: 0,+ uptime: 3600,+ template: false,+ lastBackup: 0,+ tags: [],+ lock: '',+ lastSeen: at,+});++describe('guest drawer alert memory basis', () => {+ it.each(['current', 'last-known', 'unavailable', 'future-state', undefined])(+ 'does not derive an alert comparison from a %s guest observation',+ (state) => {+ const value = guest(state);+ value.memory.usageUnavailable = state === 'unavailable';+ const copy = getGuestDrawerAlertAttention(+ alert,+ {+ guest: value,+ memoryDisplayBasis: 'host',+ parentMemoryTotal: 8 * 1024 ** 3,+ },+ now,+ );+ expect(copy).toEqual({ message: alert.message, detail: note });+ // A refreshed poll and different host capacity cannot rewrite the alert's evidence.+ value.lastSeen = '2026-10-12T05:30:00Z';+ value.memory.used = 3 * 1024 ** 3;+ expect(+ getGuestDrawerAlertAttention(+ alert,+ {+ guest: value,+ memoryDisplayBasis: 'host',+ parentMemoryTotal: 16 * 1024 ** 3,+ },+ now,+ ),+ ).toEqual(copy);+ },+ );++ it.each([0, undefined, NaN, -1, Infinity])(+ 'explains the selected basis even when host capacity is %s',+ (parentMemoryTotal) => {+ const value = guest('current');+ value.memory.used = 0;+ expect(+ getGuestDrawerAlertAttention(+ alert,+ {+ guest: value,+ memoryDisplayBasis: 'host',+ parentMemoryTotal,+ },+ now,+ ),+ ).toEqual({ message: alert.message, detail: note });+ },+ );++ it.each(['breaching', 'latched', 'recovering'] as const)(+ 'preserves alert-owned %s values, times, clear rules and hover evidence',+ (phase) => {+ const evaluated: Alert = {+ ...alert,+ metricStatus: {+ phase,+ value: 72,+ unit: '%',+ observedAt: at,+ trigger: 85,+ recovery: 70,+ lastBreachAt: '2026-10-12T04:40:00Z',+ recoveryDelaySeconds: 300,+ },+ };+ const original = getAlertAttentionCopy(evaluated, now);+ const copy = getGuestDrawerAlertAttention(+ evaluated,+ {+ guest: guest('unavailable'),+ memoryDisplayBasis: 'host',+ parentMemoryTotal: 8 * 1024 ** 3,+ },+ now,+ );+ expect(copy.message).toBe(original.message);+ expect(copy.title).toBe(original.title);+ expect(copy.detail).toBe(`${original.detail} ${note}`);+ expect(copy.message).not.toContain('13%');+ expect(evaluated.value).toBe(86.6);+ expect(evaluated.metricStatus?.value).toBe(72);+ },+ );++ it.each(['guest', undefined] as const)(+ 'keeps %s-basis attention unchanged',+ (memoryDisplayBasis) => {+ expect(+ getGuestDrawerAlertAttention(alert, { guest: guest(), memoryDisplayBasis }, now),+ ).toEqual(getAlertAttentionCopy(alert, now));+ },+ );++ it.each(['cpu', 'disk', 'temperature'])('does not annotate a %s alert', (type) => {+ const independent = { ...alert, type };+ expect(+ getGuestDrawerAlertAttention(+ independent,+ {+ guest: guest('last-known'),+ memoryDisplayBasis: 'host',+ parentMemoryTotal: 8 * 1024 ** 3,+ },+ now,+ ),+ ).toEqual(getAlertAttentionCopy(independent, now));+ });+});diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.tsindex fb7bf2b107..18a033dee2 100644--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts@@ -97,21 +97,12 @@ export const getGuestDrawerAlertAttention = (return copy;}- const used = context.guest.memory?.used;- const hostTotal = context.parentMemoryTotal;- const hostShare =- typeof used === 'number' &&- Number.isFinite(used) &&- used >= 0 &&- typeof hostTotal === 'number' &&- Number.isFinite(hostTotal) &&- hostTotal > 0- ? formatPercent((used / hostTotal) * 100)- : null;- const comparison = hostShare- ? `guest allocation · ${hostShare} of host capacity`- : 'guest allocation · row uses host capacity';- return { ...copy, message: `${copy.message} (${comparison})` };+ // The alert owns its evaluated reading and time. Today's guest bytes and+ // parent capacity cannot translate that observation, even when current;+ // retained or unavailable bytes are still less suitable. Explain the two+ // bases without inserting an unrelated number into the alert's evidence.+ const comparison = 'Alert percentages use guest allocation. The table row uses host capacity.';+ return { ...copy, detail: [copy.detail, comparison].filter(Boolean).join(' ') };};const getGuestDrawerDiskUsage = (guest: Guest): number | undefined => {