Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

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.md
index 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 boundaries
Workloads uses an encoded instance/node tuple for UI node scopes, grouping and
diff --git a/frontend-modern/browser-tests/guest-alert-memory-basis.cjs b/frontend-modern/browser-tests/guest-alert-memory-basis.cjs
new file mode 100644
index 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.html
new file mode 100644
index 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.tsx
new file mode 100644
index 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.json
new file mode 100644
index 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.tsx
index 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(() => (
<GuestDrawer
guest={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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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 => {