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.

Show one explicit backup completion time across Workloads

pulse-triage[bot]d58f27493e31
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 76759c8ba5..792e3be5ff 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -9434,3 +9434,22 @@ WebKit exercise the real policy producer, consuming drawer, shared clock and
existing table evidence. No route, guest check, backup, threshold, collector or
permission changes. This presentation result does not establish thaw, covered
filesystem writes, native restart recovery or containing released software.
+
+### One explicit guest backup completion time (12 October 2026)
+
+The Workloads backup badge and name-cell indicator disclose the same UTC
+completion date/time as the guest drawer, including on the fine-pointer hover
+shortcut. `formatBackupCompletionTime` normalises the original instant once per
+disclosed readout; the semantic `time` preserves its ISO timestamp. Local browser
+timezone and locale cannot silently change the visible calendar day or time.
+The completion text wraps at narrow widths. Unknown/future/absent readings still
+have no completion element; running or ended activity and clock ticks do not
+renew it. Only replacement evidence changes the supplied completed time.
+
+`BackupCompletionTime.test.tsx`, `BackupStatusAccess.test.tsx` and the formatter
+controls connect both disclosure paths to the drawer, offset inputs, updates,
+uncertainty and disposal. The `backup-completion-time` browser fixture uses real
+VM/LXC rows, policy producer, hover, keyboard/touch dialogs and the guest drawer
+in non-UTC desktop and phone contexts. This is unambiguous presentation, not
+PBS verification ingestion, independent thaw, filesystem liveness, native
+guest restart recovery or containing software availability.
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 3904c300de..19c4fefe68 100644
--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
@@ -4100,3 +4100,21 @@ future/backwards-clock uncertainty and timer disposal. Connected
backup-activity, configured policy and caution/absence controls. Browser proof
uses the real read-only AlertsAPI/store and existing drawer/table badge with
synthetic timestamps, not native backup safety, guest recovery or availability.
+
+### Backup time formatting stays disclosure-local (12 October 2026)
+
+The existing Workloads backup evidence uses a shared, explicit UTC completion
+formatter instead of reparsing the timestamp separately for the ISO attribute,
+local date and unlabelled local time. A closed row does not call the formatter;
+it is an accessor consumed only by mounted hover/dialog evidence. The drawer
+uses the same formatter after existing completed-evidence admission. No new
+poll, per-row timer, history read, retained cache, alert evaluation or guest
+operation is introduced, and saved freshness thresholds remain unchanged.
+
+`BackupCompletionTime.test.tsx` checks mounted same-guest updates, activity,
+shared-clock ticks and disposed timers; existing backup-clock tests retain
+policy-boundary coverage. `backupCompletionTime.test.ts` checks equivalent
+offset/numeric/Date inputs and unusable timestamp safety. Browser proof checks
+that disclosures and passive ticks add no API requests while production
+table/drawer times agree in opposing non-UTC contexts. This is not whole-fleet
+CPU/RSS relief or native guest/backup recovery.
diff --git a/frontend-modern/browser-tests/backup-completion-time.cjs b/frontend-modern/browser-tests/backup-completion-time.cjs
new file mode 100644
index 0000000000..fbded91e7a
--- /dev/null
+++ b/frontend-modern/browser-tests/backup-completion-time.cjs
@@ -0,0 +1,392 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const assert = require('node:assert/strict');
+const { chromium, webkit } = require('playwright');
+const root = '/workspace';
+const frontend = path.join(root, 'frontend-modern');
+const output = path.join(root, 'tmp/backup-completion-time/browser');
+const origin = 'http://127.0.0.1:5298';
+const start = Date.parse('2026-10-12T02:00:00Z');
+const iso = '2026-10-12T00:30:00.000Z';
+const label = '2026-10-12 00:30:00 UTC';
+const runtime = [
+ 'frontend-modern/src/utils/format.ts',
+ 'frontend-modern/src/components/Workloads/GuestRowCells.tsx',
+ 'frontend-modern/src/components/Workloads/guestDrawerModel.ts',
+];
+const hash = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+const result = {
+ base: '60bd0ffc621436e036e80140c85a687fcbae3cfa',
+ sourceHashes: Object.fromEntries(
+ runtime.map((p) => [p, hash(fs.readFileSync(path.join(root, p)))]),
+ ),
+ playwright: require('playwright/package.json').version,
+ scope:
+ 'Real AlertsAPI policy read, production VM/LXC row, table badge/indicator/hover, shared dialog and guest drawer with synthetic completion timestamps. Non-UTC desktop/phone contexts; no native backup, guest operation or availability claim.',
+ checks: [],
+ requests: [],
+ loaded: {},
+ captures: [],
+ browsers: [],
+ errors: [],
+ consoleErrors: [],
+ cleanup: {},
+};
+let server;
+(async () => {
+ fs.mkdirSync(output, { recursive: true });
+ assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync(path.join(root, 'tests/integration/package-lock.json'))).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+ );
+ const { createServer } = await import(
+ path.join(frontend, 'node_modules/vite/dist/node/index.js')
+ );
+ server = await createServer({
+ root: frontend,
+ configFile: path.join(frontend, 'vite.config.ts'),
+ cacheDir: path.join(output, 'vite-cache'),
+ optimizeDeps: { noDiscovery: true, include: ['solid-js', 'solid-js/web', '@solidjs/router'] },
+ server: { host: '127.0.0.1', port: 5298, strictPort: true },
+ logLevel: 'error',
+ });
+ await server.listen();
+ await server.transformRequest('/src/index.css');
+ await server.transformRequest('/browser-tests/backup-completion-time.tsx');
+ for (const spec of [
+ {
+ name: 'desktop-west',
+ engine: chromium,
+ launch: { headless: true, channel: 'chromium', args: ['--no-sandbox'] },
+ viewport: { width: 1365, height: 900 },
+ timezoneId: 'America/Los_Angeles',
+ locale: 'en-US',
+ colorScheme: 'light',
+ },
+ {
+ name: 'phone-east',
+ engine: webkit,
+ launch: { headless: true },
+ viewport: { width: 390, height: 844 },
+ timezoneId: 'Asia/Tokyo',
+ locale: 'ja-JP',
+ colorScheme: 'dark',
+ isMobile: true,
+ hasTouch: true,
+ },
+ ]) {
+ const browser = await spec.engine.launch(spec.launch);
+ result.browsers.push({
+ name: spec.name,
+ version: browser.version(),
+ viewport: spec.viewport,
+ timezoneId: spec.timezoneId,
+ locale: spec.locale,
+ });
+ let context;
+ try {
+ context = await browser.newContext({
+ viewport: spec.viewport,
+ timezoneId: spec.timezoneId,
+ locale: spec.locale,
+ colorScheme: spec.colorScheme,
+ isMobile: !!spec.isMobile,
+ hasTouch: !!spec.hasTouch,
+ });
+ const page = await context.newPage();
+ page.setDefaultTimeout(8000);
+ await page.clock.install({ time: start - 300_000 });
+ await page.clock.pauseAt(start);
+ page.on('pageerror', (e) => result.errors.push({ browser: spec.name, message: e.message }));
+ page.on('console', (m) => {
+ if (m.type() === 'error') result.consoleErrors.push({ browser: spec.name, text: m.text() });
+ });
+ await page.route('**/*', async (route) => {
+ const req = route.request(),
+ url = new URL(req.url());
+ if (url.origin !== origin) {
+ result.errors.push({ external: req.url() });
+ return route.abort();
+ }
+ if (url.pathname.startsWith('/api/')) {
+ const record = {
+ browser: spec.name,
+ method: req.method(),
+ path: url.pathname,
+ query: url.search,
+ };
+ result.requests.push(record);
+ assert.equal(req.method(), 'GET', 'proof is read-only');
+ let body,
+ status = 200;
+ if (url.pathname === '/api/alerts/config')
+ body = {
+ enabled: true,
+ activationState: 'active',
+ backupDefaults: { freshHours: 1, staleHours: 3 },
+ };
+ else if (url.pathname === '/api/license/runtime-capabilities')
+ body = {
+ capabilities: [],
+ limits: [],
+ max_history_days: 90,
+ runtime: { build: 'community', label: 'Fixture community' },
+ };
+ else if (url.pathname === '/api/alerts/active') body = [];
+ else if (url.pathname === '/api/resources')
+ body = { data: [], pagination: { page: 1, limit: 100, total: 0, totalPages: 1 } };
+ else if (url.pathname === '/api/ai/intelligence') body = null;
+ else if (url.pathname === '/api/ai/intelligence/anomalies')
+ body = { anomalies: [], count: 0 };
+ else if (
+ url.pathname.startsWith('/api/resources/') &&
+ url.pathname.endsWith('/operator-state')
+ )
+ body = { configured: false, state: null };
+ else if (url.pathname.startsWith('/api/guests/metadata/')) body = { customUrl: '' };
+ else {
+ status = 404;
+ body = {};
+ record.unmatched = true;
+ }
+ record.status = status;
+ return route.fulfill({
+ status,
+ contentType: 'application/json',
+ body: JSON.stringify(body),
+ });
+ }
+ if (url.pathname.startsWith('/src/')) {
+ const local = path.join(frontend, decodeURIComponent(url.pathname));
+ if (fs.existsSync(local))
+ result.loaded[path.relative(root, local)] = hash(fs.readFileSync(local));
+ }
+ return route.continue();
+ });
+ await page.routeWebSocket(/\/ws(?:\?|$)/, () => {});
+ await page.goto(`${origin}/browser-tests/backup-completion-time.html`, {
+ waitUntil: 'domcontentloaded',
+ timeout: 30000,
+ });
+ await page.getByTestId('proof-policy').getByText('Policy read', { exact: true }).waitFor();
+ if (spec.colorScheme === 'dark')
+ await page.evaluate(() => document.documentElement.classList.add('dark'));
+ const table = page.getByRole('region', { name: 'Backup table row' });
+ const badge = () => table.getByRole('button', { name: /^Backup status:/ });
+ // Running changes the existing indicator's accessible name; use its
+ // native disclosure semantics, then separately assert its activity copy.
+ const indicator = () => table.locator('button[aria-haspopup="dialog"]');
+ const dialog = () => page.getByRole('dialog', { name: /^Backup status details for / });
+ const drawerTime = () =>
+ page
+ .getByTestId('guest-technical-details')
+ .getByText('Last completed backup', { exact: true })
+ .locator('xpath=ancestor::tr')
+ .locator('time');
+ const record = async (name) => {
+ const hasTime = await dialog().locator('time').count();
+ result.checks.push({
+ browser: spec.name,
+ name,
+ time: hasTime ? await dialog().locator('time').textContent() : null,
+ datetime: hasTime ? await dialog().locator('time').getAttribute('datetime') : null,
+ });
+ };
+ const capture = async (name) => {
+ const p = path.join(output, `${spec.name}-${name}.png`);
+ await page.screenshot({ path: p, fullPage: true });
+ result.captures.push({
+ path: path.relative(root, p),
+ bytes: fs.statSync(p).size,
+ sha256: hash(fs.readFileSync(p)),
+ });
+ };
+ const checkTime = async (expectedLabel = label, expectedIso = iso) => {
+ const time = dialog().locator('time');
+ await time.waitFor();
+ assert.equal(await time.textContent(), expectedLabel);
+ assert.equal(await time.getAttribute('datetime'), expectedIso);
+ assert.equal(await drawerTime().textContent(), expectedLabel);
+ assert.equal(await drawerTime().getAttribute('datetime'), expectedIso);
+ assert(
+ await time.evaluate((e) => e.scrollWidth <= e.clientWidth),
+ 'completion text must not be clipped',
+ );
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+ };
+ const open = async (trigger) => {
+ if (spec.hasTouch) await trigger.tap();
+ else {
+ await trigger.focus();
+ await page.keyboard.press('Enter');
+ }
+ await dialog().waitFor();
+ await dialog().evaluate(async (e) => {
+ await Promise.all(
+ e
+ .getAnimations({ subtree: true })
+ .filter((a) => Number.isFinite(a.effect?.getTiming().iterations))
+ .map((a) => a.finished.catch(() => {})),
+ );
+ });
+ assert.equal(await trigger.getAttribute('aria-expanded'), 'true');
+ assert.equal(await page.getByTestId('proof-actions').innerText(), 'Row actions: 0');
+ assert(
+ await page
+ .getByRole('button', { name: 'Close backup details' })
+ .evaluate((e) => e === document.activeElement),
+ );
+ };
+ const close = async (trigger) => {
+ await page.keyboard.press('Escape');
+ assert.equal(await dialog().count(), 0);
+ assert(await trigger.evaluate((e) => e === document.activeElement));
+ };
+ const local = await page.evaluate(
+ (iso) => ({
+ date: new Date(iso).toLocaleDateString(),
+ hour: new Date(iso).getHours(),
+ zone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+ }),
+ iso,
+ );
+ assert.equal(local.zone, spec.timezoneId);
+ assert.notEqual(local.hour, 0);
+ result.checks.push({
+ browser: spec.name,
+ name: 'local context genuinely differs from UTC',
+ local,
+ });
+ for (const type of ['qemu', 'lxc']) {
+ await page.selectOption('#proof-type', type);
+ await page.selectOption('#proof-state', 'numeric');
+ const beforeOpen = result.requests.length;
+ await open(badge());
+ await checkTime();
+ assert.equal(result.requests.length, beforeOpen, 'opening evidence performs no API reads');
+ await record(`${type}: native row badge and drawer agree across local calendar/time`);
+ if (type === 'qemu') await capture('completed-dialog');
+ for (const state of ['offset-west', 'offset-east']) {
+ await page.selectOption('#proof-state', state);
+ await checkTime();
+ await record(`${type}: ${state} producer observation keeps the same absolute time`);
+ }
+ await page.selectOption('#proof-state', 'running');
+ assert(await dialog().getByText('Backup running now…', { exact: true }).isVisible());
+ const beforeTick = result.requests.length;
+ await page.clock.runFor(60_000);
+ await checkTime();
+ assert(
+ result.requests
+ .slice(beforeTick)
+ .every((r) => r.path === '/api/ai/intelligence/anomalies'),
+ 'passive tick adds no requests beyond the unchanged row anomaly poll',
+ );
+ await record(`${type}: running activity and passive age do not renew completion`);
+ await page.selectOption('#proof-state', 'ended');
+ await checkTime();
+ await page.selectOption('#proof-state', 'new');
+ await checkTime('2026-10-12 01:45:00 UTC', '2026-10-12T01:45:00.000Z');
+ await record(`${type}: only replacement completion changes both surfaces`);
+ await page.selectOption('#proof-state', 'invalid');
+ assert.equal(await dialog().locator('time').count(), 0);
+ assert.equal(await drawerTime().count(), 0);
+ assert((await dialog().innerText()).includes('invalid timestamp'));
+ await record(`${type}: invalid timestamp withdraws the time without calling it absence`);
+ if (type === 'qemu' && spec.hasTouch) await capture('unknown-dialog');
+ await page.selectOption('#proof-state', 'absent');
+ assert.equal(await dialog().locator('time').count(), 0);
+ assert((await dialog().innerText()).includes('No completed backup yet'));
+ await record(`${type}: first running backup has no completed time`);
+ await page.selectOption('#proof-state', 'future');
+ assert.equal(await dialog().locator('time').count(), 0);
+ assert((await dialog().innerText()).includes('timestamp is in the future'));
+ const beforeFuture = result.requests.length;
+ await page.clock.runFor(30_000);
+ assert.equal(
+ await dialog().locator('time').getAttribute('datetime'),
+ await drawerTime().getAttribute('datetime'),
+ );
+ assert.equal(
+ await dialog().locator('time').textContent(),
+ await drawerTime().textContent(),
+ );
+ assert(
+ result.requests
+ .slice(beforeFuture)
+ .every((r) => r.path === '/api/ai/intelligence/anomalies'),
+ );
+ await record(`${type}: now-valid supplied time reappears, no new observation manufactured`);
+ await close(badge());
+ await record(`${type}: Escape returns focus to the row disclosure`);
+ }
+ await page.selectOption('#proof-type', 'qemu');
+ await page.selectOption('#proof-state', 'numeric');
+ if (!spec.hasTouch) {
+ await badge().hover();
+ const tooltip = page
+ .locator('[data-tooltip-portal="true"]')
+ .filter({ hasText: 'Last completed backup' });
+ await tooltip.waitFor();
+ assert.equal(await tooltip.locator('time').textContent(), label);
+ assert.equal(await tooltip.locator('time').getAttribute('datetime'), iso);
+ await record('fine-pointer hover presents the same UTC evidence');
+ await capture('completed-hover');
+ await page.mouse.move(1200, 850);
+ }
+ await page.getByRole('button', { name: 'Hide Backup column', exact: true }).click();
+ await page.selectOption('#proof-state', 'running');
+ const beforeIndicator = result.requests.length;
+ assert((await indicator().getAttribute('aria-label')).startsWith('Backup running now'));
+ await open(indicator());
+ await checkTime();
+ assert.equal(result.requests.length, beforeIndicator);
+ if (spec.hasTouch) {
+ const target = await indicator().boundingBox();
+ assert(target.width >= 24 && target.height >= 24);
+ }
+ await record(
+ 'name-cell indicator retains explicit completion time, activity and row-action isolation',
+ );
+ await capture('running-indicator');
+ await close(indicator());
+ await record('indicator Escape returns focus without opening the row');
+ } finally {
+ if (context) {
+ await context.close();
+ result.cleanup[`${spec.name}-context`] = 'closed';
+ }
+ await browser.close();
+ result.cleanup[`${spec.name}-browser`] = 'closed';
+ }
+ }
+ assert.equal(result.errors.length, 0);
+ assert.equal(result.consoleErrors.length, 0);
+ assert(!result.requests.some((r) => r.unmatched));
+ for (const p of runtime) assert.equal(result.loaded[p], result.sourceHashes[p]);
+ result.result = 'passed';
+})()
+ .catch((e) => {
+ result.result = 'failed';
+ result.failure = String(e.stack || e);
+ process.exitCode = 1;
+ })
+ .finally(async () => {
+ if (server) {
+ await server.close();
+ result.cleanup.server = 'closed';
+ }
+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2));
+ console.log(
+ JSON.stringify({
+ result: result.result,
+ checks: result.checks.length,
+ captures: result.captures.length,
+ failure: result.failure,
+ cleanup: result.cleanup,
+ }),
+ );
+ });
diff --git a/frontend-modern/browser-tests/backup-completion-time.html b/frontend-modern/browser-tests/backup-completion-time.html
new file mode 100644
index 0000000000..b5aaa0d6ae
--- /dev/null
+++ b/frontend-modern/browser-tests/backup-completion-time.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>Backup completion time verification</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="./backup-completion-time.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/backup-completion-time.tsx b/frontend-modern/browser-tests/backup-completion-time.tsx
new file mode 100644
index 0000000000..3013239203
--- /dev/null
+++ b/frontend-modern/browser-tests/backup-completion-time.tsx
@@ -0,0 +1,158 @@
+// Existing producer/readouts only: synthetic timestamps, no guest or backup operations.
+import { createSignal, onMount } 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 { DarkModeContext } from '../src/contexts/appRuntime';
+import { useAlertsActivation } from '../src/stores/alertsActivation';
+import type { WorkloadGuest } from '../src/types/workloads';
+import '../src/index.css';
+
+const original = Date.parse('2026-10-12T00:30:00Z');
+function Fixture() {
+ const [type, setType] = createSignal<'qemu' | 'lxc'>('qemu');
+ const [timestamp, setTimestamp] = createSignal<string | number>(original);
+ const [running, setRunning] = createSignal(false);
+ const [showBackup, setShowBackup] = createSignal(true);
+ const [rowActions, setRowActions] = createSignal(0);
+ const [policyReady, setPolicyReady] = createSignal(false);
+ const policy = useAlertsActivation();
+ onMount(async () => {
+ await policy.refreshConfig();
+ setPolicyReady(true);
+ });
+ const guest = (): WorkloadGuest => ({
+ id: 'time-fixture:pve-a:101',
+ name: type() === 'qemu' ? 'backup-vm' : 'backup-ct',
+ instance: 'time-fixture',
+ node: 'pve-a',
+ vmid: 101,
+ type: type(),
+ platformType: 'proxmox-pve',
+ status: 'running',
+ cpu: 0.1,
+ cpus: 2,
+ memory: { total: 1024 ** 3, used: 1024 ** 3 / 4, free: (3 * 1024 ** 3) / 4, usage: 25 },
+ disk: { total: 10 * 1024 ** 3, used: 0, free: 10 * 1024 ** 3, usage: 0 },
+ networkIn: 0,
+ networkOut: 0,
+ diskRead: 0,
+ diskWrite: 0,
+ uptime: 3600,
+ template: false,
+ tags: [],
+ lock: running() ? 'backup' : '',
+ // The native workload producer supplies milliseconds. Unit controls
+ // separately exercise the cell's string-input compatibility.
+ lastBackup:
+ typeof timestamp() === 'number' ? (timestamp() as number) : Date.parse(String(timestamp())),
+ backupInProgress: running(),
+ lastSeen: '2026-10-12T02:00:00Z',
+ });
+ const change = (state: string) => {
+ setRunning(state === 'running' || state === 'absent');
+ switch (state) {
+ case 'offset-west':
+ setTimestamp('2026-10-11T17:30:00-07:00');
+ break;
+ case 'offset-east':
+ setTimestamp('2026-10-12T09:30:00+09:00');
+ break;
+ case 'new':
+ setTimestamp('2026-10-12T01:45:00Z');
+ break;
+ case 'invalid':
+ setTimestamp(NaN);
+ break;
+ case 'absent':
+ setTimestamp(0);
+ break;
+ case 'future':
+ setTimestamp(Date.now() + 30_000);
+ break;
+ default:
+ setTimestamp(original);
+ }
+ };
+ return (
+ <main class="min-h-screen space-y-4 bg-surface p-3 text-base-content">
+ <h1 class="text-base font-semibold">Backup completion time</h1>
+ <p class="text-xs text-muted">Synthetic evidence only; no backup or guest commands.</p>
+ <div class="flex flex-wrap items-center gap-3 text-xs">
+ <label>
+ Guest type{' '}
+ <select
+ id="proof-type"
+ value={type()}
+ onChange={(e) => setType(e.currentTarget.value as 'qemu' | 'lxc')}
+ >
+ <option value="qemu">VM</option>
+ <option value="lxc">LXC</option>
+ </select>
+ </label>
+ <label>
+ Observation{' '}
+ <select id="proof-state" onChange={(e) => change(e.currentTarget.value)}>
+ {[
+ 'numeric',
+ 'offset-west',
+ 'offset-east',
+ 'running',
+ 'ended',
+ 'new',
+ 'invalid',
+ 'absent',
+ 'future',
+ ].map((state) => (
+ <option value={state}>{state}</option>
+ ))}
+ </select>
+ </label>
+ <button
+ type="button"
+ class="rounded-sm border border-border p-2"
+ onClick={() => setShowBackup(!showBackup())}
+ >
+ {showBackup() ? 'Hide Backup column' : 'Show Backup column'}
+ </button>
+ </div>
+ <p data-testid="proof-policy" class="text-xs text-muted">
+ {policyReady() ? 'Policy read' : 'Reading policy'}
+ </p>
+ <section aria-label="Backup table row">
+ <table class="w-full table-fixed">
+ <tbody>
+ <GuestRow
+ guest={guest()}
+ visibleColumnIds={showBackup() ? ['name', 'backup'] : ['name']}
+ workloadTableLayoutMode={window.innerWidth <= 768 ? 'phone' : 'wide'}
+ onClick={() => setRowActions((n) => n + 1)}
+ />
+ </tbody>
+ </table>
+ </section>
+ <p data-testid="proof-actions" class="text-xs text-muted">
+ Row actions: {rowActions()}
+ </p>
+ <GuestDrawer guest={guest()} onClose={() => {}} />
+ </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/d5cb70a590bf5d08.json b/frontend-modern/browser-verification/d5cb70a590bf5d08.json
new file mode 100644
index 0000000000..cba3842da3
--- /dev/null
+++ b/frontend-modern/browser-verification/d5cb70a590bf5d08.json
@@ -0,0 +1,82 @@
+{
+ "version": 1,
+ "result": "passed",
+ "base_sha": "60bd0ffc621436e036e80140c85a687fcbae3cfa",
+ "changed_paths": [
+ "frontend-modern/src/utils/format.ts",
+ "frontend-modern/src/components/Workloads/GuestRowCells.tsx",
+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/utils/format.ts": "3239389ca80fcda409753972e96d4db17693e484b54310e7137a766ba2688111",
+ "frontend-modern/src/components/Workloads/GuestRowCells.tsx": "5ac3f5aa7c9e61e9a96360e168814c252f922b4465de4c48dc5e831709878894",
+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts": "40ba78e29e0a0e5f11e50597f511cdc5902bb364255eb07cb6608dc4e0dd4c3c"
+ },
+ "routes": [
+ "/browser-tests/backup-completion-time.html (isolated existing production Workloads row/drawer fixture; no product route added)"
+ ],
+ "states": [
+ "completed VM/LXC numeric timestamps",
+ "equivalent offset producer observations",
+ "running/ended activity without renewed completion",
+ "replacement completion only",
+ "invalid/absent/future and now-valid supplied evidence",
+ "non-UTC local calendar and locale differences"
+ ],
+ "interactions": [
+ "real AlertsAPI saved-policy GET",
+ "keyboard and touch disclosure, Escape closure and focus return, no row-action propagation",
+ "desktop fine-pointer hover shortcut",
+ "passive clock tick with unchanged existing 30-second anomaly polling only; no added backup/guest/history reads",
+ "native view_image inspection of all six final captures"
+ ],
+ "viewports": [
+ {
+ "width": 1365,
+ "height": 900
+ },
+ {
+ "width": 390,
+ "height": 844
+ }
+ ],
+ "verified_at": "2026-10-12T18:41:13.404255Z",
+ "proof_scope": "Real AlertsAPI policy read, production VM/LXC row, table badge/indicator/hover, shared dialog and guest drawer with synthetic completion timestamps. Non-UTC desktop/phone contexts; no native backup, guest operation or availability claim.",
+ "browser_proof": {
+ "checks": 43,
+ "loaded_production_hashes": 214,
+ "captures": 6,
+ "client_exit": 0,
+ "playwright": "1.56.1",
+ "browsers": [
+ {
+ "name": "desktop-west",
+ "version": "141.0.7390.37",
+ "viewport": {
+ "width": 1365,
+ "height": 900
+ },
+ "timezoneId": "America/Los_Angeles",
+ "locale": "en-US"
+ },
+ {
+ "name": "phone-east",
+ "version": "26.0",
+ "viewport": {
+ "width": 390,
+ "height": 844
+ },
+ "timezoneId": "Asia/Tokyo",
+ "locale": "ja-JP"
+ }
+ ],
+ "cleanup": {
+ "desktop-west-context": "closed",
+ "desktop-west-browser": "closed",
+ "phone-east-context": "closed",
+ "phone-east-browser": "closed",
+ "server": "closed"
+ },
+ "dossier": "RECEIPTS.md / browser/result.json and native-image-review.json"
+ }
+}
diff --git a/frontend-modern/src/components/Workloads/GuestRowCells.tsx b/frontend-modern/src/components/Workloads/GuestRowCells.tsx
index f69be05198..f6f1c1cc18 100644
--- a/frontend-modern/src/components/Workloads/GuestRowCells.tsx
+++ b/frontend-modern/src/components/Workloads/GuestRowCells.tsx
@@ -6,7 +6,13 @@ import { TooltipPortal } from '@/components/shared/TooltipPortal';
import { useTooltip } from '@/hooks/useTooltip';
import { useAlertsActivation } from '@/stores/alertsActivation';
import type { GuestNetworkInterface } from '@/types/api';
-import { formatBytes, formatRelativeTime, getBackupInfo, type BackupInfo } from '@/utils/format';
+import {
+ formatBackupCompletionTime,
+ formatBytes,
+ formatRelativeTime,
+ getBackupInfo,
+ type BackupInfo,
+} from '@/utils/format';
import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import type { AvailabilityProbePresentation } from '@/utils/availabilityProbePresentation';
import {
@@ -337,6 +343,10 @@ function BackupStatusCell(props: {
: getBackupAgeBadgeLabel(props.lastBackup, info(), now()),
);
const hasCompletedBackup = createMemo(() => info().ageMs !== null);
+ // Parse/format only when the evidence is disclosed, not for every closed
+ // table row on each shared-clock tick. Unknown/future evidence has no time.
+ const completionTime = () =>
+ hasCompletedBackup() ? formatBackupCompletionTime(props.lastBackup!) : null;
const ariaLabel = createMemo(() => {
const currentInfo = info();
if (props.indicator) {
@@ -369,24 +379,19 @@ function BackupStatusCell(props: {
<Show when={props.backupRunning}>
<p class="text-blue-600 dark:text-blue-400">Backup running now…</p>
</Show>
- <Show when={hasCompletedBackup()}>
- <div class="space-y-1">
- <div class="text-muted">Last completed backup</div>
- <time
- class="block font-medium text-base-content"
- dateTime={new Date(props.lastBackup!).toISOString()}
- >
- {new Date(props.lastBackup!).toLocaleDateString(undefined, {
- weekday: 'short',
- year: 'numeric',
- month: 'short',
- day: 'numeric',
- })}
- {' · '}
- {new Date(props.lastBackup!).toLocaleTimeString()}
- </time>
- <div class="text-base-content">{info().ageFormatted}</div>
- </div>
+ <Show when={completionTime()}>
+ {(completion) => (
+ <div class="space-y-1">
+ <div class="text-muted">Last completed backup</div>
+ <time
+ class="block whitespace-normal wrap-break-word font-medium text-base-content"
+ dateTime={completion().completedAt}
+ >
+ {completion().dateLabel}
+ </time>
+ <div class="text-base-content">{info().ageFormatted}</div>
+ </div>
+ )}
</Show>
<Show when={info().status === 'unknown'}>
<p class="text-amber-700 dark:text-amber-300">{info().ageFormatted}</p>
diff --git a/frontend-modern/src/components/Workloads/__tests__/BackupCompletionTime.test.tsx b/frontend-modern/src/components/Workloads/__tests__/BackupCompletionTime.test.tsx
new file mode 100644
index 0000000000..9e3b966905
--- /dev/null
+++ b/frontend-modern/src/components/Workloads/__tests__/BackupCompletionTime.test.tsx
@@ -0,0 +1,117 @@
+import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';
+import { createSignal } from 'solid-js';
+import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest';
+import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';
+import { BackupIndicator, BackupStatusCell } from '../GuestRowCells';
+import { getGuestDrawerBackupPresentation } from '../guestDrawerModel';
+
+vi.mock('@/stores/alertsActivation', () => ({
+ useAlertsActivation: () => ({ getBackupThresholds: () => undefined }),
+}));
+
+const now = Date.parse('2026-10-12T02:00:00Z');
+const completed = Date.parse('2026-10-12T00:30:00Z');
+const iso = '2026-10-12T00:30:00.000Z';
+const label = '2026-10-12 00:30:00 UTC';
+let clockIntervals: MockInstance<typeof globalThis.setInterval>;
+let clockClears: MockInstance<typeof globalThis.clearInterval>;
+
+beforeEach(() => {
+ vi.useFakeTimers();
+ vi.setSystemTime(now);
+ clockIntervals = vi.spyOn(globalThis, 'setInterval');
+ clockClears = vi.spyOn(globalThis, 'clearInterval');
+});
+afterEach(() => {
+ cleanup();
+ // Observe ownership directly, rather than counting unrelated test-DOM
+ // scheduled work: the shared clock must clear each interval it started.
+ expect(clockIntervals).toHaveBeenCalledTimes(1);
+ for (const interval of clockIntervals.mock.results) {
+ expect(clockClears).toHaveBeenCalledWith(interval.value);
+ }
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+});
+
+describe('one explicit completion time across backup evidence surfaces', () => {
+ it.each(['badge', 'indicator'] as const)(
+ 'regression: %s shows the same labelled instant as the drawer, not unlabelled local time',
+ (variant) => {
+ render(() =>
+ variant === 'badge' ? (
+ <BackupStatusCell lastBackup={completed} />
+ ) : (
+ <BackupIndicator lastBackup={completed} isTemplate={false} />
+ ),
+ );
+ fireEvent.click(screen.getByRole('button', { name: /^(Backup status|Last backup):/ }));
+ const time = screen.getByRole('dialog').querySelector('time')!;
+ expect(time).toHaveAttribute('datetime', iso);
+ expect(time.textContent).toBe(label);
+ expect(time.textContent).toBe(
+ getGuestDrawerBackupPresentation(completed, undefined, now).dateLabel,
+ );
+ },
+ );
+
+ it.each(['2026-10-11T17:30:00-07:00', '2026-10-12T09:30:00+09:00', '2026-10-12T00:30:00Z'])(
+ 'regression: equivalent producer time %s retains one UTC date and instant',
+ (value) => {
+ render(() => <BackupStatusCell lastBackup={value} />);
+ fireEvent.click(screen.getByRole('button', { name: /^Backup status:/ }));
+ const time = screen.getByRole('dialog').querySelector('time')!;
+ expect(time).toHaveAttribute('datetime', iso);
+ expect(time.textContent).toBe(label);
+ expect(time.textContent).toBe(
+ getGuestDrawerBackupPresentation(value, undefined, now).dateLabel,
+ );
+ },
+ );
+
+ it('keeps a mounted disclosure tied to the completion, not activity or the age clock', () => {
+ const [value, setValue] = createSignal<string | number>(completed);
+ const [running, setRunning] = createSignal(false);
+ render(() => <BackupStatusCell lastBackup={value()} backupRunning={running()} />);
+ fireEvent.click(screen.getByRole('button', { name: /^Backup status:/ }));
+ const dialog = screen.getByRole('dialog');
+ const time = () => dialog.querySelector('time');
+ expect(time()?.textContent).toBe(label);
+ setRunning(true);
+ expect(dialog).toHaveTextContent('Backup running now');
+ vi.advanceTimersByTime(60_000);
+ expect(time()).toHaveAttribute('datetime', iso);
+ expect(time()?.textContent).toBe(label);
+ expect(dialog).toHaveTextContent('1 hour ago');
+ setRunning(false);
+ expect(time()).toHaveAttribute('datetime', iso);
+ setValue('2026-10-12T01:45:00Z');
+ expect(time()?.textContent).toBe('2026-10-12 01:45:00 UTC');
+ expect(time()).toHaveAttribute('datetime', '2026-10-12T01:45:00.000Z');
+ expect(dialog).not.toHaveTextContent(label);
+ });
+
+ it('withdraws unknown/future/absent times and re-admits only the supplied completion', () => {
+ const [value, setValue] = createSignal<string | number>(completed);
+ render(() => <BackupStatusCell lastBackup={value()} backupRunning />);
+ fireEvent.click(screen.getByRole('button', { name: /^Backup status:/ }));
+ const dialog = screen.getByRole('dialog');
+ for (const invalid of ['invalid', NaN, Infinity, -1, 8.64e15 + 1]) {
+ setValue(invalid);
+ expect(dialog.querySelector('time')).toBeNull();
+ expect(dialog).toHaveTextContent('invalid timestamp');
+ expect(dialog).not.toHaveTextContent('Invalid Date');
+ }
+ setValue(0);
+ expect(dialog.querySelector('time')).toBeNull();
+ expect(dialog).toHaveTextContent('No completed backup yet');
+ setValue(now + RELATIVE_TIME_TICK_MS);
+ expect(dialog.querySelector('time')).toBeNull();
+ expect(dialog).toHaveTextContent('timestamp is in the future');
+ vi.advanceTimersByTime(RELATIVE_TIME_TICK_MS);
+ expect(dialog.querySelector('time')).toHaveAttribute('datetime', '2026-10-12T02:00:30.000Z');
+ expect(dialog.querySelector('time')?.textContent).toBe('2026-10-12 02:00:30 UTC');
+ expect(dialog).toHaveTextContent('Backup running now');
+ expect(dialog).toHaveTextContent('0s ago');
+ });
+});
diff --git a/frontend-modern/src/components/Workloads/__tests__/BackupStatusAccess.test.tsx b/frontend-modern/src/components/Workloads/__tests__/BackupStatusAccess.test.tsx
index e0986f7944..7c5d5843da 100644
--- a/frontend-modern/src/components/Workloads/__tests__/BackupStatusAccess.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/BackupStatusAccess.test.tsx
@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { createSignal } from 'solid-js';
import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';
import { BackupIndicator, BackupStatusCell } from '../GuestRowCells';
+import { getGuestDrawerBackupPresentation } from '../guestDrawerModel';
vi.mock('@/stores/alertsActivation', () => ({
useAlertsActivation: () => ({ getBackupThresholds: () => undefined }),
@@ -37,14 +38,11 @@ describe('backup evidence access', () => {
fireEvent.click(trigger);
const dialog = screen.getByRole('dialog', { name: 'Backup status details' });
expect(dialog).toHaveTextContent('Last completed backup');
- expect(dialog).toHaveTextContent(
- new Date(completed).toLocaleDateString(undefined, {
- weekday: 'short',
- year: 'numeric',
- month: 'short',
- day: 'numeric',
- }),
- );
+ const completion = dialog.querySelector('time')!;
+ const drawer = getGuestDrawerBackupPresentation(completed, undefined, now);
+ expect(completion).toHaveAttribute('datetime', drawer.completedAt);
+ expect(completion).toHaveTextContent('2026-10-05 06:00:00 UTC');
+ expect(completion.textContent).toBe(drawer.dateLabel);
expect(dialog).toHaveTextContent('2 hours ago');
expect(trigger).toHaveAttribute('aria-expanded', 'true');
await Promise.resolve();
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
index 9219465410..abeca143d6 100644
--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
@@ -3091,9 +3091,11 @@ describe('GuestRow backup evidence disclosure', () => {
it.each([{ columns: ['name', 'backup'] }, { columns: ['name'] }])(
'opens read-only evidence without triggering the enclosing row for columns %j',
({ columns }) => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date('2026-10-12T02:00:00Z'));
const onClick = vi.fn();
renderGuestRow({
- guest: makeGuest({ lastBackup: Date.now() - 3600000 }),
+ guest: makeGuest({ lastBackup: Date.parse('2026-10-12T00:30:00Z') }),
visibleColumnIds: columns,
onClick,
});
@@ -3101,9 +3103,11 @@ describe('GuestRow backup evidence disclosure', () => {
name: columns.includes('backup') ? /^Backup status:/ : /^Last backup:/,
});
fireEvent.click(trigger);
- expect(
- screen.getByRole('dialog', { name: 'Backup status details for test-vm' }),
- ).toHaveTextContent('Last completed backup');
+ const dialog = screen.getByRole('dialog', { name: 'Backup status details for test-vm' });
+ expect(dialog).toHaveTextContent('Last completed backup');
+ const completedTime = dialog.querySelector('time')!;
+ expect(completedTime).toHaveAttribute('datetime', '2026-10-12T00:30:00.000Z');
+ expect(completedTime.textContent).toBe('2026-10-12 00:30:00 UTC');
expect(onClick).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole('button', { name: 'Close backup details' }));
expect(screen.queryByRole('dialog')).toBeNull();
diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
index d9b26fdb02..217d574733 100644
--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts
+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
@@ -11,7 +11,13 @@ import {
getAlertAttentionCopy,
type AlertAttentionCopy,
} from '@/features/alerts/metricAlertPresentation';
-import { formatBytes, formatPercent, getBackupInfo, type BackupThresholds } from '@/utils/format';
+import {
+ formatBackupCompletionTime,
+ formatBytes,
+ formatPercent,
+ getBackupInfo,
+ type BackupThresholds,
+} from '@/utils/format';
import {
getWorkloadGuestDiskRead,
getWorkloadGuestDiskStatusMessage,
@@ -645,7 +651,7 @@ export const getGuestDrawerBackupPresentation = (
dateLabel: 'Unknown',
};
}
- const completedAt = new Date(timestamp!).toISOString();
+ const completion = formatBackupCompletionTime(timestamp!)!;
const daysSince = Math.floor(info.ageMs / (1000 * 60 * 60 * 24));
return {
@@ -653,7 +659,6 @@ export const getGuestDrawerBackupPresentation = (
// Elapsed age, not a rolling-day calendar claim: a 23-hour-old backup
// need not have completed today. Keep older ages in days, like the table.
ageLabel: daysSince === 0 ? info.ageFormatted : `${daysSince}d ago`,
- dateLabel: completedAt.replace('T', ' ').replace(/\.\d{3}Z$/, ' UTC'),
- completedAt,
+ ...completion,
};
};
diff --git a/frontend-modern/src/utils/__tests__/backupCompletionTime.test.ts b/frontend-modern/src/utils/__tests__/backupCompletionTime.test.ts
new file mode 100644
index 0000000000..c12e54d52c
--- /dev/null
+++ b/frontend-modern/src/utils/__tests__/backupCompletionTime.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { formatBackupCompletionTime } from '../format';
+
+describe('backup completion timestamp formatting', () => {
+ it.each([
+ Date.parse('2026-10-12T00:30:00.123Z'),
+ new Date('2026-10-12T00:30:00.123Z'),
+ '2026-10-11T17:30:00.123-07:00',
+ '2026-10-12T09:30:00.123+09:00',
+ ])('normalises equivalent instant %s without a local calendar or timezone', (value) => {
+ expect(formatBackupCompletionTime(value)).toEqual({
+ completedAt: '2026-10-12T00:30:00.123Z',
+ dateLabel: '2026-10-12 00:30:00 UTC',
+ });
+ });
+
+ it.each(['invalid', '', NaN, Infinity, -1, 0, 8.64e15 + 1, new Date(NaN)])(
+ 'does not throw or manufacture an instant from unusable input %s',
+ (value) => {
+ expect(formatBackupCompletionTime(value)).toBeNull();
+ },
+ );
+});
diff --git a/frontend-modern/src/utils/format.ts b/frontend-modern/src/utils/format.ts
index 2cae0d53c0..bb7e69620f 100644
--- a/frontend-modern/src/utils/format.ts
+++ b/frontend-modern/src/utils/format.ts
@@ -285,6 +285,21 @@ export interface BackupInfo {
ageFormatted: string;
}
+// Both the table disclosure and guest drawer must identify the same instant,
+// even when the browser's local date differs from the provider's. This only
+// formats a timestamp; callers still admit completed evidence with getBackupInfo.
+export function formatBackupCompletionTime(
+ timestamp: string | number | Date,
+): { completedAt: string; dateLabel: string } | null {
+ const date = new Date(timestamp instanceof Date ? timestamp.getTime() : timestamp);
+ if (!Number.isFinite(date.getTime()) || date.getTime() <= 0) return null;
+ const completedAt = date.toISOString();
+ return {
+ completedAt,
+ dateLabel: completedAt.replace('T', ' ').replace(/\.\d{3}Z$/, ' UTC'),
+ };
+}
+
// Default thresholds (used when no config is provided)
const DEFAULT_FRESH_HOURS = 24;
const DEFAULT_STALE_HOURS = 72;