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 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.md
index 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 connection
The existing By date source cell and Coverage restore-evidence source cell
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index 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 placement
The existing frontend location scope retains the backup reader's connection
diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.md
index 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 owner
Existing By date and Coverage consumers show each restore point's backup
diff --git a/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx
index 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">
<PlatformResourceDetailToggleButton
expanded={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.tsx
index 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): DetailSe
makeDetailRow('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">
<PlatformResourceDetailToggleButton
expanded={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.tsx
index 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(() => (
<ProxmoxCoverageTable
rows={[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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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',