Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Keep backup workload scope visible across cluster namesakes
pulse-triage[bot]a4b94f34e275
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 8b32180204..d652a352e5 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -20,6 +20,28 @@## Purpose+### Backup workload scope stays visible independently of its reader++Coverage retains the guest's PVE connection in its identity cell at every+container width. When Target ID is hidden, type and VMID remain beside the+name. Native disclosure names include the workload label and PVE connection;+the existing Coverage and By date Workload details show the full wrapped+connection, separate from the restore point's backup-reader Connection.+A missing VM/LXC connection stays Not reported, including unmatched PBS+evidence; PBS readers, namespaces and nodes never supply it. Host backups+imply no PVE connection. Displayed scope does not change identity matching,+resource/artifact keys, owner-link IDs, search/filter behaviour, completion,+protection policy, verification, access or guest/recovery operations.++The normal-suite `backupWorkloadIdentity.test.tsx` exercises inventory parser,+recovery model and both table consumers, five layouts, duplicate names/IDs/nodes,+unknown/unmatched/host scope, distinct PBS origins, exact owner links, literal+text and same-key live updates with disclosure focus. Existing windowed-table+proof remains applicable; the Coverage row-height estimate accounts for its+second identity line. Browser proof must inspect real desktop/narrow consumers,+full long/unknown details and keyboard/touch interactions. This does not+establish original multi-surface identity, collector, guest or restore recovery.+### Restore evidence names its source connectionThe existing By date source cell and Coverage restore-evidence source celldiff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.mdindex 5035da940b..15316623ad 100644--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md@@ -21,6 +21,28 @@## Purpose+### Backup workload scope stays visible independently of its reader++Coverage retains the guest's PVE connection in its identity cell at every+container width. When Target ID is hidden, type and VMID remain beside the+name. Native disclosure names include the workload label and PVE connection;+the existing Coverage and By date Workload details show the full wrapped+connection, separate from the restore point's backup-reader Connection.+A missing VM/LXC connection stays Not reported, including unmatched PBS+evidence; PBS readers, namespaces and nodes never supply it. Host backups+imply no PVE connection. Displayed scope does not change identity matching,+resource/artifact keys, owner-link IDs, search/filter behaviour, completion,+protection policy, verification, access or guest/recovery operations.++The normal-suite `backupWorkloadIdentity.test.tsx` exercises inventory parser,+recovery model and both table consumers, five layouts, duplicate names/IDs/nodes,+unknown/unmatched/host scope, distinct PBS origins, exact owner links, literal+text and same-key live updates with disclosure focus. Existing windowed-table+proof remains applicable; the Coverage row-height estimate accounts for its+second identity line. Browser proof must inspect real desktop/narrow consumers,+full long/unknown details and keyboard/touch interactions. This does not+establish original multi-surface identity, collector, guest or restore recovery.+### Restore-point origin is distinct from workload placementThe existing frontend location scope retains the backup reader's connectiondiff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex 378adb42b2..eef8e84597 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -23,6 +23,28 @@ and sort the complete canonical change table while startup and ingestion wait.## Purpose+### Backup workload scope stays visible independently of its reader++Coverage retains the guest's PVE connection in its identity cell at every+container width. When Target ID is hidden, type and VMID remain beside the+name. Native disclosure names include the workload label and PVE connection;+the existing Coverage and By date Workload details show the full wrapped+connection, separate from the restore point's backup-reader Connection.+A missing VM/LXC connection stays Not reported, including unmatched PBS+evidence; PBS readers, namespaces and nodes never supply it. Host backups+imply no PVE connection. Displayed scope does not change identity matching,+resource/artifact keys, owner-link IDs, search/filter behaviour, completion,+protection policy, verification, access or guest/recovery operations.++The normal-suite `backupWorkloadIdentity.test.tsx` exercises inventory parser,+recovery model and both table consumers, five layouts, duplicate names/IDs/nodes,+unknown/unmatched/host scope, distinct PBS origins, exact owner links, literal+text and same-key live updates with disclosure focus. Existing windowed-table+proof remains applicable; the Coverage row-height estimate accounts for its+second identity line. Browser proof must inspect real desktop/narrow consumers,+full long/unknown details and keyboard/touch interactions. This does not+establish original multi-surface identity, collector, guest or restore recovery.+### Backup evidence keeps the reader connection separate from its ownerExisting By date and Coverage consumers show each restore point's backupdiff --git a/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsxindex 2f8e521fb6..0ac5891816 100644--- a/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx+++ b/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx@@ -44,6 +44,8 @@ import {ProxmoxBackupWorkloadTypeBadge,SortableHead,artifactStateLabel,+ getBackupWorkloadPVEConnection,+ getBackupWorkloadDisclosureLabel,} from './proxmoxBackupsTableShared';import {getCoverageColumns,@@ -188,6 +190,9 @@ const buildCoverageDetailSections = (row: WorkloadCoverageRow): DetailSection[]makeDetailRow('Type', row.workload.typeLabel),makeDetailRow(PROXMOX_BACKUP_COLUMN_LABELS.targetId, row.workload.vmid),makeDetailRow('Node', row.workload.node),+ makeDetailRow('PVE connection', getBackupWorkloadPVEConnection(row.workload), {+ wrap: true,+ }),makeDetailRow('Latest task', row.latestTask?.label, {tone: row.latestTask? statusDetailTone(taskWordVariant(row.latestTask.label))@@ -233,9 +238,9 @@ const buildCoverageDetailSections = (row: WorkloadCoverageRow): DetailSection[]// expanding to its restore evidence. Presentational — the parent owns the// filtered+sorted memo, shared filters, and the expansion set. table-fixed + a// colgroup keeps the columns from ballooning; the inner evidence table stays-// content-sized. Rows are single-line with one datum per column — identity-// (Type / Target ID / Node) gets its own columns, mirroring the by-date-// recoverable table, instead of stacking under the workload name.+// content-sized. The name cell retains the guest's connection at every width;+// Type / Target ID fold beside the name when their columns are hidden. The+// guest's connection is independent of its restore-evidence reader below.export function ProxmoxCoverageTable(props: {rows: WorkloadCoverageRow[];hasAnyRows: boolean;@@ -374,7 +379,7 @@ export function ProxmoxCoverageTable(props: {items={() => props.rows}keyExtractor={(row) => row.key}colSpan={columnCount()}- estimatedRowHeight={32}+ estimatedRowHeight={44}reserveScrollExtent>{(row) => {@@ -398,14 +403,37 @@ export function ProxmoxCoverageTable(props: {<div class="flex min-w-0 items-center gap-2"><PlatformResourceDetailToggleButtonexpanded={isExpanded()}- resourceLabel={row.workload.label}+ resourceLabel={getBackupWorkloadDisclosureLabel(row.workload)}controlsId={detailRowId()}onToggle={() => props.onToggleExpand(row.key)}/><div class="min-w-0">- <div class="truncate font-semibold">- {row.workload.name || row.workload.label}+ <div class="flex min-w-0 items-center gap-1">+ <span class="truncate font-semibold" title={row.workload.label}>+ {row.workload.name || row.workload.label}+ </span>+ <Show+ when={+ !columnVisible('targetId') &&+ (row.workload.type === 'vm' || row.workload.type === 'ct')+ }+ >+ <span class="shrink-0 text-[10px] text-muted">+ {row.workload.typeLabel} {row.workload.vmid}+ </span>+ </Show></div>+ <Show when={getBackupWorkloadPVEConnection(row.workload)}>+ {(connection) => (+ <span+ class="block truncate text-[10px] text-muted"+ title={`PVE connection: ${connection()}`}+ data-backup-workload-connection+ >+ PVE: {connection()}+ </span>+ )}+ </Show></div></div></TableCell>diff --git a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsxindex 634119d117..937e57aa7a 100644--- a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx+++ b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx@@ -41,6 +41,8 @@ import {RowMetricBar,SortableHead,artifactStateLabel,+ getBackupWorkloadPVEConnection,+ getBackupWorkloadDisclosureLabel,} from './proxmoxBackupsTableShared';import {getRecoverableColumns,@@ -147,6 +149,9 @@ const buildRecoverableDetailSections = (artifact: RecoverableArtifact): DetailSemakeDetailRow('Type', artifact.workload.typeLabel),makeDetailRow(PROXMOX_BACKUP_COLUMN_LABELS.targetId, artifact.workload.vmid),makeDetailRow('Node', artifact.workload.node),+ makeDetailRow('PVE connection', getBackupWorkloadPVEConnection(artifact.workload), {+ wrap: true,+ }),]),},{@@ -235,7 +240,7 @@ export function ProxmoxRecoverableTable(props: {<div class="flex min-w-0 items-center gap-1"><PlatformResourceDetailToggleButtonexpanded={drawer.isExpanded(artifact)}- resourceLabel={artifact.workload.name || artifact.workload.label}+ resourceLabel={getBackupWorkloadDisclosureLabel(artifact.workload)}controlsId={drawer.detailRowId(artifact)}onToggle={() => drawer.toggle(artifact)}/>diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsxindex 87ff4a3884..6c7c3dbd52 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx@@ -69,7 +69,7 @@ const headerTexts = () =>afterEach(cleanup);describe('ProxmoxCoverageTable column visibility', () => {- it('renders single-line rows with identity columns matching the by-date table', () => {+ it('keeps full-width identity columns alongside the workload connection', () => {renderInRouter(() => (<ProxmoxCoverageTablerows={[row]}@@ -99,7 +99,8 @@ describe('ProxmoxCoverageTable column visibility', () => {expect(headers).not.toContain('Guest snapshot');expect(headers).not.toContain('PVE file');expect(headers).not.toContain('Task');- // Identity data lives in dedicated cells, not stacked under the name.+ // Full width retains its dedicated identity cells. The connection remains+ // in the name cell at every width, including explicit unknown scope.expect(document.body.textContent).toContain('VM');expect(document.body.textContent).toContain('100');expect(document.body.textContent).toContain('pve1');diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsxindex d4a7d18874..3bf7fee62a 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx@@ -62,7 +62,13 @@ describe('ProxmoxRecoverableTable record drawer', () => {const second: RecoverableArtifact = {...artifact,id: 'pbs:db:101',- workload: { ...artifact.workload, key: 'vm:101', vmid: '101', name: 'db', label: 'db' },+ workload: {+ ...artifact.workload,+ key: 'vm:101',+ vmid: '101',+ name: 'db',+ label: 'db (VM 101)',+ },location: 'offsite / pbs2',};renderInRouter(() => (@@ -83,7 +89,9 @@ describe('ProxmoxRecoverableTable record drawer', () => {/>));- const toggle = screen.getByRole('button', { name: 'Expand details for web' });+ const toggle = screen.getByRole('button', {+ name: 'Expand details for web (VM 100) · PVE connection: Not reported',+ });expect(toggle).toHaveAttribute('aria-controls', 'proxmox-recoverable-detail-pbs:web:100');await fireEvent.click(toggle);@@ -101,7 +109,11 @@ describe('ProxmoxRecoverableTable record drawer', () => {);// Opening another restore point closes the first.- await fireEvent.click(screen.getByRole('button', { name: 'Expand details for db' }));+ await fireEvent.click(+ screen.getByRole('button', {+ name: 'Expand details for db (VM 101) · PVE connection: Not reported',+ }),+ );expect(screen.getAllByTestId('proxmox-recoverable-detail')).toHaveLength(1);expect(screen.getByTestId('proxmox-recoverable-detail')).toHaveAttribute('data-inline-detail-for',diff --git a/frontend-modern/src/features/proxmox/__tests__/backupWorkloadIdentity.test.tsx b/frontend-modern/src/features/proxmox/__tests__/backupWorkloadIdentity.test.tsxnew file mode 100644index 0000000000..f8d5c232e3--- /dev/null+++ b/frontend-modern/src/features/proxmox/__tests__/backupWorkloadIdentity.test.tsx@@ -0,0 +1,234 @@+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';+import { Route, Router } from '@solidjs/router';+import { createSignal } from 'solid-js';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';+import type { PBSBackup, PVEBackupsPayload } from '@/types/api';+import { protectionPolicy } from '@/utils/__fixtures__/protectionPosture';+import { ProxmoxBackupsTable } from '../ProxmoxBackupsTable';+import {+ BACKUP_IDENTITY_NOW,+ identityArchive,+ identityGuest,+ identityPBS,+} from '../__fixtures__/backupIdentity';++const api = vi.hoisted(() => ({ fetch: vi.fn(), json: vi.fn(), width: 390 }));+vi.mock('@/utils/apiClient', () => ({ apiFetch: api.fetch, apiFetchJSON: api.json }));+vi.mock('@/hooks/useObservedElementWidth', () => ({+ useObservedElementWidth: () => ({ setElement: () => {}, width: () => api.width }),+}));++const guests = () =>+ ['east', 'west'].map((instance) => ({+ ...identityGuest(`guest-${instance}`, instance, 'pve-1'),+ name: 'same-name',+ displayName: 'same-name',+ }));+const emptyPVE: PVEBackupsPayload = { backupTasks: [], storageBackups: [], guestSnapshots: [] };+const archives = (): PVEBackupsPayload => ({+ ...emptyPVE,+ storageBackups: ['east', 'west'].map((instance) =>+ identityArchive({ id: `file-${instance}`, instance }),+ ),+});+const response = (data: unknown) =>+ new Response(JSON.stringify({ data }), { headers: { 'Content-Type': 'application/json' } });+function mount({ workloads = guests(), pve = archives(), pbs = [] as PBSBackup[] } = {}) {+ const [current, setWorkloads] = createSignal(workloads);+ api.fetch.mockImplementation((url: string) =>+ Promise.resolve(response(url === '/api/backups/pbs' ? { backups: pbs } : pve)),+ );+ // Visible inventory never establishes canonical protection.+ api.json.mockResolvedValue({ data: [], policy: protectionPolicy });+ render(() => (+ <Router>+ <Route+ path="/*"+ component={() => <ProxmoxBackupsTable emptyIcon={<span />} workloads={current()} />}+ />+ </Router>+ ));+ return setWorkloads;+}+async function coverageRows() {+ await screen.findAllByText('same-name');+ return Array.from(document.querySelectorAll<HTMLElement>('[data-proxmox-backup-row="coverage"]'));+}+const connectionOf = (row: HTMLElement) =>+ row.querySelector('[data-backup-workload-connection]')?.textContent;+const connectionRow = (detail: HTMLElement) =>+ within(detail).getByText('PVE connection', { exact: true }).closest('tr')!;++beforeEach(() => {+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });+ vi.resetAllMocks();+ api.width = 390;+ resetCreateNonSuspendingQueryCacheForTest();+ window.history.replaceState({}, '', '/proxmox/backups/coverage');+});+afterEach(() => {+ cleanup();+ resetCreateNonSuspendingQueryCacheForTest();+ vi.useRealTimers();+});++describe('backup workload identity in real inventory consumers', () => {+ it.each([330, 600, 800, 1000, 1200])(+ 'distinguishes identical guest names/VMIDs/nodes at %ipx without changing their evidence or owner',+ async (width) => {+ api.width = width;+ mount();+ const rows = await coverageRows();+ expect(rows).toHaveLength(2);+ for (const scope of ['east', 'west']) {+ const row = rows.find((item) => connectionOf(item) === `PVE: ${scope}`)!;+ expect(row).toBeDefined();+ expect(row).toHaveTextContent('same-name');+ expect(row).toHaveTextContent('100');+ const toggle = within(row).getByRole('button', {+ name: `Expand details for same-name (VM 100) · PVE connection: ${scope}`,+ });+ fireEvent.click(toggle);+ const detail = screen.getByTestId('proxmox-coverage-detail');+ expect(connectionRow(detail)).toHaveTextContent(scope);+ expect(within(detail).getByRole('link', { name: 'Open same-name' })).toHaveAttribute(+ 'href',+ `/proxmox/overview?resource=guest-${scope}`,+ );+ const sources = detail.querySelectorAll('[data-backup-source-connection]');+ expect(sources).toHaveLength(1);+ expect(sources[0]).toHaveTextContent(`Connection: ${scope}`);+ expect(detail).toHaveTextContent('Not verified');+ fireEvent.click(toggle);+ }+ expect(screen.getByRole('button', { name: '2 unknown' })).toBeInTheDocument();+ expect(api.fetch).toHaveBeenCalledTimes(2);+ },+ );++ it('keeps the PVE workload scope separate from its PBS reader and namespace in both details', async () => {+ mount({+ workloads: guests().slice(0, 1),+ pve: emptyPVE,+ pbs: [identityPBS({ instance: 'pbs-reader', namespace: 'unrelated-namespace' })],+ });+ const [row] = await coverageRows();+ expect(connectionOf(row)).toBe('PVE: east');+ fireEvent.click(within(row).getByRole('button', { name: /expand details/ }));+ let detail = screen.getByTestId('proxmox-coverage-detail');+ expect(connectionRow(detail)).toHaveTextContent('east');+ expect(connectionRow(detail)).not.toHaveTextContent('pbs-reader');+ expect(detail.querySelector('[data-backup-source-connection]')).toHaveTextContent(+ 'Connection: pbs-reader',+ );+ await fireEvent.click(screen.getByRole('link', { name: /by date/i }));+ const point = await screen.findByRole('button', {+ name: 'Expand details for same-name (VM 100) · PVE connection: east',+ });+ fireEvent.click(point);+ detail = screen.getByTestId('proxmox-recoverable-detail');+ expect(connectionRow(detail)).toHaveTextContent('east');+ expect(within(detail).getByText('Connection', { exact: true }).closest('tr')).toHaveTextContent(+ 'pbs-reader',+ );+ expect(detail).toHaveTextContent('main / unrelated-namespace');+ expect(within(detail).getByRole('link')).toHaveAttribute(+ 'href',+ '/proxmox/overview?resource=guest-east',+ );+ expect(api.fetch).toHaveBeenCalledTimes(2);+ });++ it('never borrows a PBS reader or namespace for unmatched guest scope, or invents a host PVE connection', async () => {+ mount({+ workloads: [],+ pve: emptyPVE,+ pbs: [+ identityPBS({ instance: 'pbs-reader', namespace: 'east' }),+ identityPBS({ id: 'host-point', backupType: 'host', vmid: 'nas-box' }),+ ],+ });+ const vm = await screen.findByRole('button', {+ name: 'Expand details for VM 100 · PVE connection: Not reported',+ });+ fireEvent.click(vm);+ let detail = screen.getByTestId('proxmox-coverage-detail');+ expect(connectionRow(detail)).toHaveTextContent('Not reported');+ expect(connectionRow(detail)).not.toHaveTextContent('east');+ expect(detail.querySelector('[data-backup-source-connection]')).toHaveTextContent('pbs-reader');+ expect(within(detail).queryByRole('link')).not.toBeInTheDocument();+ const host = screen.getByRole('button', { name: /expand details for Host nas-box/i });+ expect(host).not.toHaveAccessibleName(/PVE connection/i);+ fireEvent.click(host);+ detail = screen.getByTestId('proxmox-coverage-detail');+ expect(within(detail).queryByText('PVE connection')).not.toBeInTheDocument();+ expect(within(detail).queryByRole('link')).not.toBeInTheDocument();+ await fireEvent.click(screen.getByRole('link', { name: /by date/i }));+ fireEvent.click(+ await screen.findByRole('button', {+ name: 'Expand details for VM 100 · PVE connection: Not reported',+ }),+ );+ expect(connectionRow(screen.getByTestId('proxmox-recoverable-detail'))).toHaveTextContent(+ 'Not reported',+ );+ });++ it('renders a missing live PVE connection explicitly rather than borrowing its node', async () => {+ const guest = guests()[0];+ mount({+ workloads: [{ ...guest, proxmox: { ...guest.proxmox!, instance: ' ' } }],+ pve: emptyPVE,+ });+ const [row] = await coverageRows();+ expect(connectionOf(row)).toBe('PVE: Not reported');+ fireEvent.click(within(row).getByRole('button', { name: /expand details/ }));+ expect(connectionRow(screen.getByTestId('proxmox-coverage-detail'))).toHaveTextContent(+ 'Not reported',+ );+ });++ it('uses literal connection text and keeps same-key live updates in the open panel without losing disclosure focus', async () => {+ const guest = guests()[0];+ const setWorkloads = mount({ workloads: [guest], pve: emptyPVE });+ const [row] = await coverageRows();+ const toggle = within(row).getByRole('button', { name: /expand details/ });+ fireEvent.click(toggle);+ toggle.focus();+ const detail = screen.getByTestId('proxmox-coverage-detail');+ const origin = row.querySelector('[data-backup-workload-connection]');+ const literal = '<img data-workload-injected src=x>';+ setWorkloads([{ ...guest, proxmox: { ...guest.proxmox!, instance: literal } }]);+ await waitFor(() => expect(connectionOf(row)).toBe(`PVE: ${literal}`));+ expect(row.querySelector('[data-backup-workload-connection]')).toBe(origin);+ expect(screen.getByTestId('proxmox-coverage-detail')).toBe(detail);+ expect(connectionRow(detail)).toHaveTextContent(literal);+ expect(document.querySelector('[data-workload-injected]')).toBeNull();+ expect(toggle).toHaveAccessibleName(+ `Collapse details for same-name (VM 100) · PVE connection: ${literal}`,+ );+ expect(document.activeElement).toBe(toggle);+ expect(within(detail).getByRole('link')).toHaveAttribute(+ 'href',+ '/proxmox/overview?resource=guest-east',+ );+ expect(api.fetch).toHaveBeenCalledTimes(2);+ });++ it('finds the displayed workload connection through the existing search without another read', async () => {+ mount();+ await coverageRows();+ fireEvent.input(screen.getByPlaceholderText(/Search backups by workload/), {+ target: { value: 'WEST' },+ });+ await waitFor(() =>+ expect(document.querySelectorAll('[data-proxmox-backup-row="coverage"]')).toHaveLength(1),+ );+ expect(connectionOf(document.querySelector('[data-proxmox-backup-row="coverage"]')!)).toBe(+ 'PVE: west',+ );+ expect(api.fetch).toHaveBeenCalledTimes(2);+ });+});diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupsTableShared.tsx b/frontend-modern/src/features/proxmox/proxmoxBackupsTableShared.tsxindex 97987ad43b..e9628e71c8 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupsTableShared.tsx+++ b/frontend-modern/src/features/proxmox/proxmoxBackupsTableShared.tsx@@ -42,6 +42,19 @@ export const PROXMOX_BACKUP_COLUMN_LABELS = {details: 'Details',} as const;+// This is the guest's PVE scope, not the connection reading its backup.+// Unmatched PBS evidence has no known PVE owner; its reader or namespace+// must never fill that gap. Host backups do not imply a PVE guest at all.+export const getBackupWorkloadPVEConnection = (workload: WorkloadReference): string | undefined =>+ workload.type === 'vm' || workload.type === 'ct'+ ? workload.instance?.trim() || 'Not reported'+ : undefined;++export const getBackupWorkloadDisclosureLabel = (workload: WorkloadReference): string => {+ const connection = getBackupWorkloadPVEConnection(workload);+ return connection ? `${workload.label} · PVE connection: ${connection}` : workload.label;+};+const recoveryAgeClassByBand: Record<RecoveryAgeBand, string> = {current: 'text-emerald-600 dark:text-emerald-300',aging: 'text-amber-600 dark:text-amber-300',