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 mounted backup and operational evidence ageing

pulse-triage[bot]c543d1135ded
diff --git a/frontend-modern/browser-verification/b0e87a28fdaf9860.json b/frontend-modern/browser-verification/b0e87a28fdaf9860.json
new file mode 100644
index 0000000000..77280c1b94
--- /dev/null
+++ b/frontend-modern/browser-verification/b0e87a28fdaf9860.json
@@ -0,0 +1,58 @@
+{
+ "version": 1,
+ "result": "passed",
+ "base_sha": "bdfe5b8668f188fb9f8df4a90ae0f90f0e16f9d6",
+ "changed_paths": [
+ "frontend-modern/src/components/Workloads/GuestRowCells.tsx",
+ "frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx",
+ "frontend-modern/src/components/Workloads/useGuestRowState.ts",
+ "frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx",
+ "frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx",
+ "frontend-modern/src/features/standalone/StandalonePageSurface.tsx"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/components/Workloads/GuestRowCells.tsx": "e6d3871f234016e250036641a4e25beaec6f55b384c7f63b902cfc97ba5024dd",
+ "frontend-modern/src/components/Workloads/useGuestRowState.ts": "3bbb0942323aed151ef81e36a7da07976449fbbe79d243702183261b6a2b4372",
+ "frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx": "9abb6224d8dc80f3181552eda6fc8a81d1564812e321f50b0b303c84393e346a",
+ "frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx": "bb6d57ebdf4ab18c70f12395f82f8c68fb6f82c8f95591aadd94d0de0f8eae4c",
+ "frontend-modern/src/features/standalone/StandalonePageSurface.tsx": "a9026fd3bade8efafb58a41f9b87e907fc15e5655b8a47d09aabbfc52d46f055",
+ "frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx": "17709978833073abb9385f7e773e96a3edcbd88524cfe98c6cdaa713c049fb02"
+ },
+ "routes": [
+ "/workloads (existing-row/backup fixture)",
+ "/infrastructure/proxmox (node overview fixture)",
+ "/docker (host management fixture)",
+ "/standalone/availability (real page surface on synthetic data)",
+ "/patrol (real workbench fixture)"
+ ],
+ "states": [
+ "Stable completed backup evidence at configured freshness boundary, running/unknown/absence/template controls and open read-only date evidence.",
+ "Attached guest probe expiry, retained successful/stale update checks and source withdrawal.",
+ "Queued Docker check with operator-hidden actions and summary-only management exclusion.",
+ "Availability posture and latest data on a held source, plus held Patrol list, detail, empty evaluation and flapping observations."
+ ],
+ "interactions": [
+ "Advance the existing shared clock without a new backup/probe/update result; observe ages, protection badge and probe/posture tone/count transitions.",
+ "Open and close completed-backup evidence with focus restoration; withdraw probe source and switch failed-update or summary-only evidence without executing an operation.",
+ "Select Patrol detail and expand its existing history; hold its loader after first result to prove clock-only invalidation, keeping locked autonomy and the phone-owned hidden-list state."
+ ],
+ "viewports": [
+ {
+ "width": 1280,
+ "height": 950
+ },
+ {
+ "width": 390,
+ "height": 950
+ }
+ ],
+ "verified_at": "2026-10-10T21:34:23.726Z",
+ "browser": {
+ "client": "1.56.1",
+ "engines": [
+ "Chromium 141.0.7390.37",
+ "WebKit 26.0"
+ ]
+ },
+ "scope": "Fourteen selected completed runtime cases on exact matching bytes across independently retained attempts; the two Settings cases have their own receipt. Canonical Vite config/CSS, real components/adapters/store and synthetic local input. All selected captures inspected. No full authenticated application, native notifications/guests, installed recovery or publication is claimed."
+}
diff --git a/frontend-modern/src/components/Workloads/GuestRowCells.tsx b/frontend-modern/src/components/Workloads/GuestRowCells.tsx
index 5a8f8f23a7..1c87bcd783 100644
--- a/frontend-modern/src/components/Workloads/GuestRowCells.tsx
+++ b/frontend-modern/src/components/Workloads/GuestRowCells.tsx
@@ -7,6 +7,7 @@ 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 { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import type { AvailabilityProbePresentation } from '@/utils/availabilityProbePresentation';
import {
getWorkloadsGuestBackupStatusPresentation,
@@ -66,12 +67,14 @@ function BackupIndicator(props: {
function getBackupAgeBadgeLabel(
lastBackup: string | number | null | undefined,
info: BackupInfo,
+ now: number,
): string {
if (info.status === 'never') return 'None';
if (info.status === 'unknown') return 'Unknown';
const compact = formatRelativeTime(lastBackup ?? undefined, {
compact: true,
emptyText: 'Unknown',
+ now,
});
if (compact === 'just now') return 'Now';
return compact.replace(/\s+ago$/, '');
@@ -311,13 +314,14 @@ function BackupStatusCell(props: {
indicator?: boolean;
guestName?: string;
}) {
+ const now = useRelativeTimeNow();
const tip = useTooltip();
const [detailsOpen, setDetailsOpen] = createSignal(false);
let trigger: HTMLButtonElement | undefined;
const alertsActivation = useAlertsActivation();
const info = createMemo(() =>
- getBackupInfo(props.lastBackup, alertsActivation.getBackupThresholds()),
+ getBackupInfo(props.lastBackup, alertsActivation.getBackupThresholds(), now()),
);
// The badge shows "running" while a backup is underway: green would claim
// a completed backup that does not exist yet, and the age states would
@@ -328,7 +332,9 @@ function BackupStatusCell(props: {
);
const config = createMemo(() => getWorkloadsGuestBackupStatusPresentation(displayStatus()));
const badgeLabel = createMemo(() =>
- displayStatus() === 'running' ? 'Running' : getBackupAgeBadgeLabel(props.lastBackup, info()),
+ displayStatus() === 'running'
+ ? 'Running'
+ : getBackupAgeBadgeLabel(props.lastBackup, info(), now()),
);
const hasCompletedBackup = createMemo(() => info().ageMs !== null);
const ariaLabel = createMemo(() => {
diff --git a/frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx b/frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx
index 3a8cfe813f..2d4e200477 100644
--- a/frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx
+++ b/frontend-modern/src/components/Workloads/NodeDrawerOverview.tsx
@@ -11,7 +11,7 @@ import {
import type { Alert, Disk, HostGPUSensor, Node, Temperature } from '@/types/api';
import { alertTypeDisplayLabel } from '@/features/alerts/helpers';
import { getAlertAttentionCopy } from '@/features/alerts/metricAlertPresentation';
-import { formatBytes, normalizeDiskArray } from '@/utils/format';
+import { formatBytes, formatRelativeTime, normalizeDiskArray } from '@/utils/format';
import type { MetricDisplayThresholds } from '@/utils/metricThresholds';
import { getProxmoxUpdateEvidencePresentation } from '@/utils/proxmoxUpdateEvidence';
import { formatTemperature, getCpuTemperature, getTemperatureTextClass } from '@/utils/temperature';
@@ -193,7 +193,10 @@ export function NodeDrawerOverview(props: NodeDrawerOverviewProps) {
return clock && clock !== '0' ? clock : '';
};
const loadAverageLabel = () => formatLoadAverage(props.node.loadAverage);
- const updateEvidence = () => getProxmoxUpdateEvidencePresentation(props.node);
+ const updateEvidence = () =>
+ getProxmoxUpdateEvidencePresentation(props.node, (value) =>
+ formatRelativeTime(value, { now: now() }),
+ );
const platformRows = (): NodeOverviewRow[] => [
...(cleanText(props.node.kernelVersion)
diff --git a/frontend-modern/src/components/Workloads/__tests__/NodeDrawerOverview.updateEvidence.test.tsx b/frontend-modern/src/components/Workloads/__tests__/NodeDrawerOverview.updateEvidence.test.tsx
index 14136132ad..bd997514f5 100644
--- a/frontend-modern/src/components/Workloads/__tests__/NodeDrawerOverview.updateEvidence.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/NodeDrawerOverview.updateEvidence.test.tsx
@@ -1,5 +1,5 @@
import { cleanup, render, screen } from '@solidjs/testing-library';
-import { afterEach, describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
import { NodeDrawerOverview } from '@/components/Workloads/NodeDrawerOverview';
import type { Node } from '@/types/api';
@@ -24,9 +24,36 @@ const makeNode = (overrides: Partial<Node>): Node =>
...overrides,
}) as Node;
-afterEach(cleanup);
+afterEach(() => {
+ cleanup();
+ vi.useRealTimers();
+});
describe('NodeDrawerOverview update evidence', () => {
+ it.each(['checked', 'stale'] as const)(
+ 'ages %s evidence without inventing a new check or changing its verdict',
+ (status) => {
+ const start = Date.parse('2026-10-10T12:00:00Z');
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+ const node = makeNode({
+ pendingUpdates: 0,
+ pendingUpdatesStatus: status,
+ pendingUpdatesCheckedAt: new Date(start - 60_000).toISOString(),
+ ...(status === 'stale' ? { pendingUpdatesReason: 'check_failed' as const } : {}),
+ });
+ render(() => <NodeDrawerOverview node={node} />);
+ expect(screen.getByText(/No pending updates.*checked 1 min ago/)).toBeInTheDocument();
+ vi.advanceTimersByTime(60_000);
+ expect(screen.getByText(/No pending updates.*checked 2 mins ago/)).toHaveAttribute(
+ 'title',
+ status === 'checked'
+ ? 'Last successful update check 2 mins ago'
+ : 'Latest check failed · last success 2 mins ago',
+ );
+ expect(node.pendingUpdatesStatus).toBe(status);
+ expect(node.pendingUpdatesCheckedAt).toBe(new Date(start - 60_000).toISOString());
+ },
+ );
it('shows confirmed zero evidence instead of omitting the update row', () => {
render(() => (
<NodeDrawerOverview
diff --git a/frontend-modern/src/components/Workloads/__tests__/mountedEvidenceClock.test.tsx b/frontend-modern/src/components/Workloads/__tests__/mountedEvidenceClock.test.tsx
new file mode 100644
index 0000000000..d3646ff68c
--- /dev/null
+++ b/frontend-modern/src/components/Workloads/__tests__/mountedEvidenceClock.test.tsx
@@ -0,0 +1,128 @@
+import { createSignal } from 'solid-js';
+import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { WorkloadGuest } from '@/types/workloads';
+import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';
+import { BackupIndicator, BackupStatusCell } from '../GuestRowCells';
+import { useGuestRowState } from '../useGuestRowState';
+
+vi.mock('@/stores/alertsActivation', () => ({
+ useAlertsActivation: () => ({
+ getBackupThresholds: () => ({ freshHours: 1, staleHours: 2 }),
+ getMetricThresholds: () => null,
+ }),
+}));
+vi.mock('@/hooks/useAnomalies', () => ({ useAnomalyForMetric: () => () => null }));
+vi.mock('@/hooks/useBreakpoint', () => ({ useBreakpoint: () => ({ isMobile: () => false }) }));
+
+const start = Date.parse('2026-10-10T12:00:00Z');
+const hour = 3_600_000;
+const fakeClock = () =>
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+
+afterEach(() => {
+ cleanup();
+ vi.useRealTimers();
+});
+
+describe('mounted workload evidence clock', () => {
+ it('ages both backup entry points past the configured boundaries without new evidence', () => {
+ fakeClock();
+ const lastBackup = start - hour;
+ render(() => (
+ <>
+ <BackupStatusCell lastBackup={lastBackup} guestName="Database VM" />
+ <BackupIndicator lastBackup={lastBackup} isTemplate={false} />
+ </>
+ ));
+ const badge = screen.getByRole('button', { name: /^Backup status: fresh/ });
+ const indicator = screen.getByRole('button', { name: /^Last backup:/ });
+ expect(badge).toHaveClass('text-green-600');
+ expect(indicator).toHaveClass('text-green-600');
+ fireEvent.click(badge);
+ const dialog = screen.getByRole('dialog');
+ const time = dialog.querySelector('time');
+ expect(dialog).toHaveTextContent('1 hour ago');
+
+ vi.advanceTimersByTime(RELATIVE_TIME_TICK_MS);
+ expect(badge).toHaveAccessibleName(/^Backup status: stale/);
+ expect(badge).toHaveTextContent('1h');
+ expect(indicator.className).not.toContain('green');
+ expect(badge).toHaveClass('border-yellow-200');
+ vi.advanceTimersByTime(hour);
+ expect(badge).toHaveAccessibleName(/^Backup status: overdue/);
+ expect(badge).toHaveTextContent('2h');
+ expect(dialog).toHaveTextContent('2 hours ago');
+ expect(dialog.querySelector('time')).toBe(time);
+ expect(time).toHaveAttribute('datetime', new Date(lastBackup).toISOString());
+ expect(screen.getByRole('button', { name: /^Backup status: overdue/ })).toBe(badge);
+ });
+
+ it('keeps running, invalid, absent and template semantics while the clock moves', () => {
+ fakeClock();
+ render(() => (
+ <>
+ <BackupStatusCell lastBackup={start - hour} backupRunning />
+ <BackupStatusCell lastBackup="invalid" />
+ <BackupStatusCell lastBackup={0} />
+ <BackupIndicator lastBackup={start - hour} isTemplate />
+ </>
+ ));
+ const running = screen.getByRole('button', { name: /^Backup status: backup running now/ });
+ vi.advanceTimersByTime(hour);
+ expect(running).toHaveTextContent('Running');
+ expect(running).toHaveClass('border-blue-200');
+ expect(running).toHaveAccessibleName(/last completed backup 2 hours ago/);
+ expect(screen.getByRole('button', { name: /invalid timestamp/ })).toHaveTextContent('Unknown');
+ expect(
+ screen.getByRole('button', { name: 'Backup status: no backup found' }),
+ ).toHaveTextContent('None');
+ expect(screen.getAllByRole('button')).toHaveLength(3);
+ cleanup();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('expires the existing attached probe and withdraws it without retaining a presentation', () => {
+ fakeClock();
+ const [guest, setGuest] = createSignal({
+ id: 'lab:vm:100',
+ type: 'vm',
+ name: 'Database VM',
+ status: 'running',
+ availability: {
+ enabled: true,
+ available: true,
+ protocol: 'https',
+ path: '/health',
+ correlationState: 'attached',
+ lastChecked: new Date(start - 60_000).toISOString(),
+ evidence: { validUntil: new Date(start + 10_000).toISOString() },
+ },
+ } as WorkloadGuest);
+ let latest: ReturnType<typeof useGuestRowState>;
+ render(() => {
+ latest = useGuestRowState({
+ get guest() {
+ return guest();
+ },
+ });
+ return (
+ <span data-testid="probe" class={latest.availabilityPresentation()?.toneClassName}>
+ {latest.availabilityPresentation()?.detailLabel}
+ </span>
+ );
+ });
+ const probe = screen.getByTestId('probe');
+ expect(probe).toHaveTextContent('fresh - checked 1 min ago');
+ expect(probe.className).toContain('emerald');
+ vi.advanceTimersByTime(60_000);
+ expect(probe).toHaveTextContent('stale - checked 2 mins ago');
+ expect(probe.className).toContain('amber');
+ expect(guest().availability?.available).toBe(true);
+ setGuest({ ...guest(), availability: undefined });
+ expect(latest!.availabilityPresentation()).toBeNull();
+ expect(probe).toBeEmptyDOMElement();
+ vi.advanceTimersByTime(RELATIVE_TIME_TICK_MS);
+ expect(latest!.availabilityPresentation()).toBeNull();
+ });
+});
diff --git a/frontend-modern/src/components/Workloads/useGuestRowState.ts b/frontend-modern/src/components/Workloads/useGuestRowState.ts
index 926e356ce6..415790c1d6 100644
--- a/frontend-modern/src/components/Workloads/useGuestRowState.ts
+++ b/frontend-modern/src/components/Workloads/useGuestRowState.ts
@@ -20,6 +20,7 @@ import {
} from '@/utils/workloads';
import { getDiscoveryReadinessPresentation } from '@/utils/resourceDiscoveryReadiness';
import { getAvailabilityProbePresentation } from '@/utils/availabilityProbePresentation';
+import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import { getWorkloadTypeBadge } from '@/components/shared/workloadTypeBadges';
import {
@@ -39,6 +40,7 @@ import {
} from './guestRowModel';
export function useGuestRowState(props: GuestRowProps) {
+ const now = useRelativeTimeNow();
const { isMobile } = useBreakpoint();
const alertsActivation = useAlertsActivation();
@@ -298,15 +300,20 @@ export function useGuestRowState(props: GuestRowProps) {
isDockerManagedAppContainer(props.guest) ? getWorkloadDockerHostId(props.guest) : '',
);
- const availabilityPresentation = createMemo(() =>
- getAvailabilityProbePresentation({
- type: props.guest.type as never,
- platformType: (props.guest.platformType ?? '') as never,
- status: props.guest.status as never,
- availability: props.guest.availability,
- platformData: { availability: props.guest.availability },
- }),
- );
+ const availabilityPresentation = createMemo(() => {
+ const availability = props.guest.availability;
+ if (!availability) return null;
+ return getAvailabilityProbePresentation(
+ {
+ type: props.guest.type as never,
+ platformType: (props.guest.platformType ?? '') as never,
+ status: props.guest.status as never,
+ availability,
+ platformData: { availability },
+ },
+ new Date(now()),
+ );
+ });
return {
appContainerRuntimeBadge,
diff --git a/frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx b/frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx
index 38fc07ce9c..eb2e71f918 100644
--- a/frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx
+++ b/frontend-modern/src/features/docker/DockerHostDrawerOverview.tsx
@@ -31,6 +31,7 @@ import {
normalizeDiskArray,
} from '@/utils/format';
import { formatTemperature, getTemperatureTextClass } from '@/utils/temperature';
+import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
interface DockerHostDrawerOverviewProps {
host: Resource;
@@ -80,6 +81,7 @@ const toDetailRows = (rows: DockerOverviewRow[]): DetailRow[] =>
);
export function DockerHostDrawerManagement(props: DockerHostDrawerOverviewProps) {
+ const now = useRelativeTimeNow();
const docker = () => props.host.docker;
const hostSourceId = createMemo(() => cleanText(docker()?.hostSourceId) || null);
const summaryOnly = createMemo(
@@ -114,7 +116,10 @@ export function DockerHostDrawerManagement(props: DockerHostDrawerOverviewProps)
<InfoCardKeyValueRow label="Available" value={updatesAvailable()} />
<Show when={checkedAtMillis()} keyed>
{(timestamp) => (
- <InfoCardKeyValueRow label="Last checked" value={formatRelativeTime(timestamp)} />
+ <InfoCardKeyValueRow
+ label="Last checked"
+ value={formatRelativeTime(timestamp, { now: now() })}
+ />
)}
</Show>
<Show when={hostCommand()?.type || hostCommand()?.status}>
diff --git a/frontend-modern/src/features/docker/__tests__/DockerHostDrawerManagement.clock.test.tsx b/frontend-modern/src/features/docker/__tests__/DockerHostDrawerManagement.clock.test.tsx
new file mode 100644
index 0000000000..29596c11f2
--- /dev/null
+++ b/frontend-modern/src/features/docker/__tests__/DockerHostDrawerManagement.clock.test.tsx
@@ -0,0 +1,53 @@
+import { createSignal } from 'solid-js';
+import { cleanup, render, screen } from '@solidjs/testing-library';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { Resource } from '@/types/resource';
+import { MonitoringAPI } from '@/api/monitoring';
+import { DockerHostDrawerManagement } from '../DockerHostDrawerOverview';
+
+vi.mock('@/stores/systemSettings', () => ({
+ areSystemSettingsLoaded: () => true,
+ shouldHideDockerUpdateActions: () => true,
+}));
+vi.mock('@/api/monitoring', () => ({ MonitoringAPI: { checkDockerUpdates: vi.fn() } }));
+
+afterEach(() => {
+ cleanup();
+ vi.useRealTimers();
+});
+
+describe('mounted Docker update evidence', () => {
+ it('ages the retained check without dispatch and keeps policy and command admission', () => {
+ const start = Date.parse('2026-10-10T12:00:00Z');
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+ const original = {
+ id: 'docker-lab',
+ type: 'docker-host',
+ docker: {
+ hostSourceId: 'docker-lab',
+ updatesAvailableCount: 3,
+ updatesLastCheckedAt: new Date(start - 60_000).toISOString(),
+ command: { type: 'update_check', status: 'queued' },
+ },
+ } as Resource;
+ const [host, setHost] = createSignal(original);
+ render(() => <DockerHostDrawerManagement host={host()} />);
+ const check = screen.getByRole('button', { name: 'Check updates' });
+ expect(check).toBeDisabled();
+ expect(screen.getByText('1 min ago')).toBeInTheDocument();
+ vi.advanceTimersByTime(60_000);
+ expect(screen.getByText('2 mins ago')).toBeInTheDocument();
+ expect(screen.getByRole('button', { name: 'Check updates' })).toBe(check);
+ expect(check).toBeDisabled();
+ expect(screen.queryByRole('button', { name: /Update all/ })).not.toBeInTheDocument();
+ expect(MonitoringAPI.checkDockerUpdates).not.toHaveBeenCalled();
+ expect(host()).toBe(original);
+ setHost({
+ ...original,
+ docker: { ...original.docker!, collectionMode: 'typed-helper-summary' },
+ });
+ expect(screen.queryByText('Last checked')).not.toBeInTheDocument();
+ vi.advanceTimersByTime(30_000);
+ expect(screen.queryByRole('button', { name: 'Check updates' })).not.toBeInTheDocument();
+ });
+});
diff --git a/frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx b/frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx
index 84c6aced7f..ef4a2fbecf 100644
--- a/frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx
+++ b/frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx
@@ -646,6 +646,7 @@ function AttentionList(props: {
onSelect: (itemId: string) => void;
view: PatrolAttentionView;
}) {
+ const now = useRelativeTimeNow();
const hasQuietWork = () => {
const items = patrolAttentionStore.items();
return Array.isArray(items) && items.length > 0;
@@ -779,7 +780,11 @@ function AttentionList(props: {
</span>
</Show>
<span>
- Last seen {formatRelativeTime(item.lastObservedAt, { compact: true })}
+ Last seen{' '}
+ {formatRelativeTime(item.lastObservedAt, {
+ compact: true,
+ now: now(),
+ })}
</span>
</div>
</div>
@@ -801,6 +806,7 @@ function AttentionList(props: {
}
function AttentionEmptyState(props: { hasQuietWork: boolean; view: PatrolAttentionView }) {
+ const now = useRelativeTimeNow();
const summary = () => patrolAttentionStore.summary();
const activeFilter = () => patrolAttentionStore.filter() === 'active';
const trustworthyCalm = () =>
@@ -849,7 +855,7 @@ function AttentionEmptyState(props: { hasQuietWork: boolean; view: PatrolAttenti
: 'The current operational evaluation has no active items.'}
<Show when={summary()?.evaluatedAt}>
{' Checked '}
- {formatRelativeTime(summary()!.evaluatedAt, { compact: true })}.
+ {formatRelativeTime(summary()!.evaluatedAt, { compact: true, now: now() })}.
</Show>
</p>
</Show>
@@ -886,6 +892,7 @@ function AttentionDetail(props: {
findings?: () => UnifiedFinding[];
}) {
const [copiedResourceId, setCopiedResourceId] = createSignal('');
+ const now = useRelativeTimeNow();
const detail = () => props.detail;
const item = () => detail()?.item;
const linkedFindings = createMemo(() => {
@@ -1028,7 +1035,8 @@ function AttentionDetail(props: {
<ProtectionLabel item={loaded().item} detail />
<span aria-hidden="true">·</span>
<span>
- Last seen {formatRelativeTime(loaded().item.lastObservedAt, { compact: true })}
+ Last seen{' '}
+ {formatRelativeTime(loaded().item.lastObservedAt, { compact: true, now: now() })}
</span>
</div>
<p class="mt-3 text-sm leading-6 text-base-content">
@@ -1259,10 +1267,16 @@ function AttentionDetail(props: {
<span class="font-semibold">Flapping.</span>{' '}
{flapping().transitionCount} open/resolved changes in the last{' '}
{flapping().windowHours} hours, first{' '}
- {formatRelativeTime(flapping().firstTransitionAt, { compact: true })}{' '}
+ {formatRelativeTime(flapping().firstTransitionAt, {
+ compact: true,
+ now: now(),
+ })}{' '}
and latest{' '}
- {formatRelativeTime(flapping().lastTransitionAt, { compact: true })}.
- The transitions are collapsed here so one noisy issue reads as one
+ {formatRelativeTime(flapping().lastTransitionAt, {
+ compact: true,
+ now: now(),
+ })}
+ . The transitions are collapsed here so one noisy issue reads as one
issue.
</p>
<details class="mt-2 rounded-md border border-border-subtle">
diff --git a/frontend-modern/src/features/patrol/__tests__/PatrolAttentionWorkbench.test.tsx b/frontend-modern/src/features/patrol/__tests__/PatrolAttentionWorkbench.test.tsx
index ba5f32442d..295dfe13c9 100644
--- a/frontend-modern/src/features/patrol/__tests__/PatrolAttentionWorkbench.test.tsx
+++ b/frontend-modern/src/features/patrol/__tests__/PatrolAttentionWorkbench.test.tsx
@@ -251,6 +251,74 @@ describe('PatrolAttentionWorkbench', () => {
</Router>
));
+ it('ages the retained empty-view evaluation without another list read', async () => {
+ const start = Date.parse('2026-10-10T12:00:00Z');
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+ const calm = summary({ evaluatedAt: new Date(start - 60_000).toISOString() });
+ apiMocks.getList.mockResolvedValue(listResponse([], calm));
+ try {
+ renderWorkbench();
+ expect(await screen.findByText(/Checked 1m ago/)).toBeInTheDocument();
+ // Hold the existing input at the loader boundary, independently of
+ // the workbench's ordinary 30-second polling timer.
+ const held = vi.spyOn(patrolAttentionStore, 'load').mockResolvedValue(undefined);
+ vi.advanceTimersByTime(60_000);
+ expect(screen.getByText(/Checked 2m ago/)).toBeInTheDocument();
+ expect(apiMocks.getList).toHaveBeenCalledOnce();
+ expect(calm.evaluatedAt).toBe(new Date(start - 60_000).toISOString());
+ held.mockRestore();
+ } finally {
+ cleanup();
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ }
+ });
+
+ it('ages list, detail and flapping-window observations without repeating an operation', async () => {
+ const start = Date.parse('2026-10-10T12:00:00Z');
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+ const active = item({
+ lastObservedAt: new Date(start - 60_000).toISOString(),
+ flapping: {
+ transitionCount: 11,
+ windowHours: 24,
+ firstTransitionAt: new Date(start - 10 * 60_000).toISOString(),
+ lastTransitionAt: new Date(start - 2 * 60_000).toISOString(),
+ },
+ });
+ apiMocks.getList.mockResolvedValue(
+ listResponse([active], summary({ activeCount: 1, openCount: 1, calm: false })),
+ );
+ apiMocks.getDetail.mockResolvedValue(detail(active));
+ try {
+ renderWorkbench();
+ const row = await screen.findByRole('button', { name: 'Open Database VM · Disk pressure' });
+ expect(row).toHaveTextContent('Last seen 1m ago');
+ fireEvent.click(row);
+ const detailRegion = await screen.findByRole('complementary', {
+ name: 'Database VM · Disk pressure',
+ });
+ await waitFor(() => expect(detailRegion).toHaveTextContent('Last seen 1m ago'));
+ fireEvent.click(screen.getByText('Evidence and history'));
+ expect(detailRegion).toHaveTextContent(/first 10m ago.*latest 2m ago/);
+ const held = vi.spyOn(patrolAttentionStore, 'load').mockResolvedValue(undefined);
+ vi.advanceTimersByTime(60_000);
+ expect(row).toHaveTextContent('Last seen 2m ago');
+ expect(detailRegion).toHaveTextContent('Last seen 2m ago');
+ expect(detailRegion).toHaveTextContent(/first 11m ago.*latest 3m ago/);
+ expect(apiMocks.getList).toHaveBeenCalledOnce();
+ expect(apiMocks.getDetail).toHaveBeenCalledOnce();
+ expect(apiMocks.planAction).not.toHaveBeenCalled();
+ expect(apiMocks.acknowledge).not.toHaveBeenCalled();
+ expect(active.evidenceFreshness).toBe('fresh');
+ held.mockRestore();
+ } finally {
+ cleanup();
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ }
+ });
+
it('renders a plain trustworthy calm state without a proof strip', async () => {
const calm = summary({ evaluatedAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() });
apiMocks.getList.mockResolvedValue(listResponse([], calm));
diff --git a/frontend-modern/src/features/standalone/StandalonePageSurface.tsx b/frontend-modern/src/features/standalone/StandalonePageSurface.tsx
index 908d94dad4..8d9f4cec67 100644
--- a/frontend-modern/src/features/standalone/StandalonePageSurface.tsx
+++ b/frontend-modern/src/features/standalone/StandalonePageSurface.tsx
@@ -32,6 +32,7 @@ import {
} from '@/routing/resourceLinks';
import { updateStore } from '@/stores/updates';
import { formatRelativeTime } from '@/utils/format';
+import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import { buildProbeAgentOptions } from '@/utils/availabilityProbeAgents';
import {
AvailabilityChecksTable,
@@ -69,6 +70,7 @@ const StandalonePostureCard: Component<{
noun: string;
summary: StandalonePostureSummary;
}> = (props) => {
+ const now = useRelativeTimeNow();
const headline = () => {
if (props.summary.critical > 0) {
return `${props.summary.critical} ${props.noun}${props.summary.critical === 1 ? '' : 's'} offline`;
@@ -89,7 +91,11 @@ const StandalonePostureCard: Component<{
};
const latestUpdate = () =>
props.summary.latestUpdateAt
- ? formatRelativeTime(props.summary.latestUpdateAt, { compact: true, emptyText: 'unknown' })
+ ? formatRelativeTime(props.summary.latestUpdateAt, {
+ compact: true,
+ emptyText: 'unknown',
+ now: now(),
+ })
: 'unknown';
return (
@@ -135,6 +141,7 @@ const resolveStandaloneTab = (pathname: string): StandaloneTabId =>
: 'machines';
export function StandalonePageSurface() {
+ const now = useRelativeTimeNow();
const location = useLocation();
const navigate = useNavigate();
const [searchParams, setSearchParams] = useSearchParams();
@@ -183,7 +190,7 @@ export function StandalonePageSurface() {
setSearchParams({ [STANDALONE_QUERY_PARAMS.view]: view }, { replace: true });
};
const availabilityPosture = createMemo(() =>
- buildStandalonePostureSummary(model().availabilityChecks),
+ buildStandalonePostureSummary(model().availabilityChecks, now()),
);
const showLoading = createMemo(
() =>
diff --git a/frontend-modern/src/features/standalone/__tests__/StandalonePageSurface.test.tsx b/frontend-modern/src/features/standalone/__tests__/StandalonePageSurface.test.tsx
index 01272a988e..be68f8b484 100644
--- a/frontend-modern/src/features/standalone/__tests__/StandalonePageSurface.test.tsx
+++ b/frontend-modern/src/features/standalone/__tests__/StandalonePageSurface.test.tsx
@@ -166,6 +166,57 @@ afterEach(() => {
});
describe('StandalonePageSurface', () => {
+ it('ages the availability posture and latest-data label without reloading resources', () => {
+ const start = Date.parse('2026-10-10T12:00:00Z');
+ vi.useFakeTimers({ toFake: ['Date', 'setInterval', 'clearInterval'], now: start });
+ const resources = [
+ resource({
+ id: 'clock-check',
+ type: 'network-endpoint',
+ platformType: 'availability',
+ sources: ['availability'],
+ lastSeen: start - 60_000,
+ availability: freshAvailability({
+ evidence: {
+ id: 'clock-evidence',
+ source: { provider: 'availability', collector: 'probe' },
+ subject: { resourceId: 'clock-check' },
+ observedAt: new Date(start).toISOString(),
+ ingestedAt: new Date(start).toISOString(),
+ validUntil: new Date(start + 10_000).toISOString(),
+ completeness: 'complete',
+ confidence: 'confirmed',
+ permissions: 'sufficient',
+ },
+ }),
+ }),
+ ];
+ const refetch = vi.fn();
+ mocks.pathname = '/standalone/availability';
+ mocks.useUnifiedResources.mockReturnValue({
+ resources: () => resources,
+ loading: () => false,
+ error: () => null,
+ refetch,
+ });
+ try {
+ render(() => <StandalonePageSurface />);
+ const posture = screen.getByTestId('standalone-posture-summary');
+ expect(posture).toHaveTextContent('All 1 check reporting normally');
+ expect(posture).toHaveTextContent('latest data 1m ago');
+ vi.advanceTimersByTime(60_000);
+ expect(posture).toHaveTextContent('1 check needs attention');
+ expect(posture).toHaveTextContent('0 healthy');
+ expect(posture).toHaveTextContent('latest data 2m ago');
+ expect(screen.getByTestId('standalone-posture-summary')).toBe(posture);
+ expect(refetch).not.toHaveBeenCalled();
+ expect(resources[0].availability?.available).toBe(true);
+ } finally {
+ cleanup();
+ vi.useRealTimers();
+ }
+ });
+
it('keeps machine search and normalized status in route-owned saved-view state', () => {
mocks.searchParams = { q: 'ubuntu', status: 'running' };
render(() => <StandalonePageSurface />);