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
Count restore points and name reasons on phone rows
rcourtmane06834849c29
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex c49cb88865..72d85d6c47 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -11208,6 +11208,13 @@ exercises the parsed inventory and ordinary polling through the consuming datefilter, preserving bounded reads. Backup/posture policy, source association,read cadence and guest operations are unchanged; this is not native recovery.+### PlatformResourceCounter can name what it does not count (3 November 2026)++`PlatformResourceCounter` takes an optional `detail` string, shown after the+count inside the same live status ("2982 restore points · 33 running"). It is+for rows a table lists but its noun does not cover, so the count can stay true+to the noun. Callers without it are unchanged.+### Backup polling does not choose a different workspaceBare legacy Backups links retain the useful initial health-based view choice,diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.mdindex 1726655b97..2d2a7448b8 100644--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md@@ -9358,6 +9358,19 @@ exercises the parsed inventory and ordinary polling through the consuming datefilter, preserving bounded reads. Backup/posture policy, source association,read cadence and guest operations are unchanged; this is not native recovery.+### By date counts restore points and phone rows name the reason (3 November 2026)++The By date counter read "3015 backup entries" while Backup health read "2982+completed restore points", because the list also holds running and failed+entries. The counter now counts completed restore points and names the rest+beside them ("2982 restore points · 33 running"); a filter counts the same way+("278 of 2981 restore points · 2 running"). Phone Coverage rows showed "Attn."+for every problem. They now name the server's reason in a word or two+(`compactBackupReasonLabel`: "Failed", "Overdue", "Verify late", "No backup"),+beside the reason labels Backup health uses, and fall back to the state word+for a row whose reason this build cannot name. The 80px phone cell keeps its+width, so guest names lose nothing. Protection states and sorting are unchanged.+### Bare Backups entry chooses a view once, not on each health pollHistorical since 3 November 2026: a bare entry now opens Coverage at once (seediff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex e67f3c3419..1e4fbdc6fa 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -9576,6 +9576,13 @@ actual pixels. This corrects evidence scope, not original incident causality ornative backup/guest recovery.+### Phone Coverage rows name the reason, not just the state (3 November 2026)++A compact Coverage row shows the canonical protection posture's reason in a+word or two, with the state and explanation kept for assistive technology. Row+identity, the posture itself and its sorting are unchanged, and a reason this+build does not know falls back to the state word rather than a guess.+### Coverage distinguishes assessment clocks from visible restore evidenceAn expanded Proxmox Coverage record exposes the server assessment's `evaluatedAt`,diff --git a/frontend-modern/browser-verification/8cd019c8b6704208.json b/frontend-modern/browser-verification/8cd019c8b6704208.jsonnew file mode 100644index 0000000000..4c686087a3--- /dev/null+++ b/frontend-modern/browser-verification/8cd019c8b6704208.json@@ -0,0 +1,55 @@+{+ "version": 1,+ "base_sha": "6e4b11ceb82a876c76f3efa8f8ea28d4e63c180e",+ "verified_at": "2026-11-03T22:40:00Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/features/platformPage/sharedPlatformPage.tsx",+ "frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx",+ "frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx",+ "frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts",+ "frontend-modern/src/features/proxmox/proxmoxBackupVerdict.ts",+ "frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/features/platformPage/sharedPlatformPage.tsx": "a23ac7393ddd69d77784ea663fd4c4f16a0feaa84fb83445af23345490dc8fc2",+ "frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx": "9569b0390eea3f4efc29b9b0acf6baf6db4c6963815a2ae5aaab3bf634376a93",+ "frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx": "1ee11642f6bffcfb396c7712414878d341e54b77a0c97efef536bb36d45a0a7c",+ "frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts": "7fc6d35f94794e860c61fc124a8836c4b81be173d1f381003555ea2af7e39330",+ "frontend-modern/src/features/proxmox/proxmoxBackupVerdict.ts": "08ce47a25baffcfac5f0613476fcd66fc9791248496daba1dc1db26ff8f42e2c",+ "frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts": "e7d8e1948d80d2453c9b0e7f2e01cdaac50265809674c9743e1e7e1ef84654a5"+ },+ "routes": [+ "/proxmox/backups/coverage",+ "/proxmox/backups/date"+ ],+ "viewports": [+ {+ "width": 1280,+ "height": 800+ },+ {+ "width": 390,+ "height": 844+ },+ {+ "width": 320,+ "height": 700+ }+ ],+ "states": [+ "Mock stack built from this change: 2982 completed restore points and 33 running entries",+ "Desktop By date counter reads \"2982 restore points \u00b7 33 running\", matching Backup health",+ "Filtered By date counter reads \"278 of 2981 restore points \u00b7 2 running\"",+ "Phone Coverage rows show the reason word \"Failed\" with rows at 32px and no horizontal overflow",+ "Every reason word and fallback fits the 80px cell at 390 and 320 without clipping, measured by substituting each word into a live row, because the mock only shows some reasons in view",+ "Name column keeps its width (207px at 390)",+ "Desktop Coverage keeps \"Needs attention\" and \"932 targets\" unchanged",+ "Phone screen reader text reads \"Needs attention: <explanation>\" and the short word is aria-hidden"+ ],+ "interactions": [+ "Loaded Coverage fresh at 390 and 320 and measured the word cell",+ "Switched to By date and read the counter beside the Backup health tail at 1280",+ "Loaded By date with a search filter at 1280 and read the filtered counter"+ ]+}diff --git a/frontend-modern/src/features/platformPage/__tests__/platformOverviewLayout.guardrails.test.ts b/frontend-modern/src/features/platformPage/__tests__/platformOverviewLayout.guardrails.test.tsindex 6e292f0c8e..ad78990a5f 100644--- a/frontend-modern/src/features/platformPage/__tests__/platformOverviewLayout.guardrails.test.ts+++ b/frontend-modern/src/features/platformPage/__tests__/platformOverviewLayout.guardrails.test.ts@@ -52,6 +52,8 @@ import vsphereNetworksTableSource from '@/features/vmware/VsphereNetworksTable.timport storageSurfaceSource from '@/components/Storage/Storage.tsx?raw';import useWorkloadsStateSource from '@/components/Workloads/useWorkloadsState.ts?raw';import workloadsSurfaceSource from '@/components/Workloads/WorkloadsSurface.tsx?raw';+import { render, screen } from '@solidjs/testing-library';+import { PlatformResourceCounter } from '../sharedPlatformPage';const indexCssSource = readFileSync('src/index.css', 'utf8');@@ -631,3 +633,22 @@ describe('platform overview layout guardrails', () => {);});});++describe('PlatformResourceCounter', () => {+ it('keeps what it does not count in the same live status', () => {+ render(() =>+ PlatformResourceCounter({+ visible: 278,+ total: 2981,+ rowNoun: 'restore points',+ detail: '2 running',+ }),+ );+ expect(screen.getByRole('status')).toHaveTextContent('278 of 2981 restore points · 2 running');+ });++ it('shows only the count without a detail', () => {+ render(() => PlatformResourceCounter({ visible: 1, total: 1, rowNoun: 'targets' }));+ expect(screen.getAllByRole('status').at(-1)?.textContent?.trim()).toBe('1 target');+ });+});diff --git a/frontend-modern/src/features/platformPage/sharedPlatformPage.tsx b/frontend-modern/src/features/platformPage/sharedPlatformPage.tsxindex 4f7f237793..584f6275d9 100644--- a/frontend-modern/src/features/platformPage/sharedPlatformPage.tsx+++ b/frontend-modern/src/features/platformPage/sharedPlatformPage.tsx@@ -1342,6 +1342,8 @@ export const PlatformResourceCounter: Component<{visible: number;total: number;rowNoun: string;+ /** What the table lists beyond the counted rows, such as "2 running". */+ detail?: string;}> = (props) => {const totalNoun = () => getPlatformResourceCountNoun(props.rowNoun, props.total);return (@@ -1361,6 +1363,7 @@ export const PlatformResourceCounter: Component<{>{props.visible} of {props.total} {totalNoun()}</Show>+ <Show when={props.detail}>{(detail) => <> · {detail()}</>}</Show></span>);};diff --git a/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsxindex 7b214a5f85..73945869a1 100644--- a/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx+++ b/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx@@ -41,7 +41,10 @@ import type {} from '@/types/api';import type { Resource } from '@/types/resource';import {+ isCompletedRecoveryArtifact,buildProxmoxBackupRecoveryModel,+ describeIncompleteArtifacts,+ restorePointCountNoun,coverageRowMatchesSearch,selectWorkloadRecoveryArtifacts,recoverableArtifactMatchesSearch,@@ -647,8 +650,11 @@ export const ProxmoxBackupsTable: Component<{return max;});- const totalRecoverableCount = createMemo(() => recoveryModel().recoverableArtifacts.length);- const visibleRecoverableCount = createMemo(() => filteredRecoverableArtifacts().length);+ // The list also holds running and failed entries, which are not restore+ // points yet. Count them apart so the total matches Backup health.+ const visibleCompletedCount = createMemo(+ () => filteredRecoverableArtifacts().filter(isCompletedRecoveryArtifact).length,+ );// Shared scope filters plus the per-view inline facet.const buildBackupsFilters = (): FilterDef[] => {@@ -946,15 +952,25 @@ export const ProxmoxBackupsTable: Component<{onClearAll={resetBackupsFilters}trailingControls={<PlatformResourceCounter- visible={view() === 'date' ? visibleRecoverableCount() : visibleLiveCount()}- total={view() === 'date' ? totalRecoverableCount() : liveTotalCount()}+ visible={view() === 'date' ? visibleCompletedCount() : visibleLiveCount()}+ total={+ view() === 'date'+ ? recoveryModel().coverageSummary.recoverableArtifacts+ : liveTotalCount()+ }rowNoun={view() === 'date'- ? inventoryIncomplete()- ? 'backup entries read'- : 'backup entries'+ ? restorePointCountNoun(+ recoveryModel().coverageSummary.recoverableArtifacts,+ inventoryIncomplete(),+ ): 'targets'}+ detail={+ view() === 'date'+ ? describeIncompleteArtifacts(filteredRecoverableArtifacts())+ : undefined+ }/>}/>diff --git a/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsxindex e073baec8d..92b4e6e958 100644--- a/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx+++ b/frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx@@ -75,6 +75,7 @@ import {COVERAGE_RESTORE_EVIDENCE_PAGE_SIZE,type CoverageColumnId,} from './proxmoxBackupsTablePresentation';+import { compactBackupReasonLabel } from './proxmoxBackupVerdict';import { PlatformWindowedRows } from '@/features/platformPage/PlatformWindowedRows';// Each evidence column is already named by its header, so an empty cell says@@ -157,6 +158,7 @@ const statusDetailTone = (variant: StatusIndicatorVariant): DetailValueTone | unreturn undefined;};+// The fallback for a row with no reason this build can name.const compactPostureLabel = (posture: WorkloadCoverageRow['posture']): string => {switch (posture) {case 'protected':@@ -817,8 +819,16 @@ export function ProxmoxCoverageTable(props: {</Show></TableCell></Show>- <TableCell class={getPlatformTableCellClassForKind('text')}>- <div class="flex items-center gap-2">+ <TableCell+ class={`${getPlatformTableCellClassForKind('text')} ${+ layoutMode() === 'compact' ? '!pl-1.5 !pr-0.5' : ''+ }`}+ >+ <div+ class={`flex items-center ${+ layoutMode() === 'compact' ? 'gap-1.5' : 'gap-2'+ }`}+ ><StatusDotsize="sm"variant={coveragePostureVariant(row.posture)}@@ -835,7 +845,14 @@ export function ProxmoxCoverageTable(props: {when={layoutMode() === 'compact'}fallback={getWorkloadRecoveryPostureLabel(row.posture)}>- {compactPostureLabel(row.posture)}+ <span class="sr-only">+ {getWorkloadRecoveryPostureLabel(row.posture)}:{' '}+ {postureExplanation(row)}+ </span>+ <span aria-hidden="true">+ {compactBackupReasonLabel(row) ??+ compactPostureLabel(row.posture)}+ </span></Show></span></div>diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsxindex 88dab2ceca..692d915c42 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx@@ -3019,10 +3019,16 @@ describe('restore point list follows the consuming inventory scope', () => {'shows no restore points for empty or unresolved %s',async (query) => {mountScopedInventory(query);- await screen.findByText(/7 backup entries/);+ await screen.findByText(/0 of 6 restore points/);expect(rows()).toHaveLength(0);},);++ it('counts restore points and lists running entries apart', async () => {+ mountScopedInventory('');+ await waitFor(() => expect(rows()).toHaveLength(7));+ expect(screen.getByText('6 restore points · 1 running')).toHaveAttribute('role', 'status');+ });});describe('bare Backups entry opens Coverage', () => {diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsxindex cc1384b02d..b7b6d9d621 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxCoverageTable.test.tsx@@ -14,6 +14,7 @@ import {} from '../__fixtures__/backupIdentity';import type { WorkloadCoverageRow } from '../proxmoxBackupRecoveryModel';import type { CoverageSortKey } from '../proxmoxBackupsTableModel';+import { protectionPosture } from '@/utils/__fixtures__/protectionPosture';// Record drawers link to the object they are about, which needs a router.const renderInRouter = (component: () => JSX.Element) =>@@ -405,6 +406,45 @@ describe('ProxmoxCoverageTable column visibility', () => {expect(document.body.textContent).not.toContain('VM 100 · pve1');});+ it('names the reason in a compact row, not just the state', () => {+ renderInRouter(() => (+ <ProxmoxCoverageTable+ rows={[+ {+ ...row,+ posture: 'attention',+ protectionPosture: {+ ...protectionPosture('vm:100'),+ state: 'attention',+ reason: 'stale',+ },+ },+ ]}+ hasAnyRows+ emptyIcon={<span />}+ emptyTitle=""+ emptyDescription=""+ sortKey={(() => 'posture') as Accessor<CoverageSortKey>}+ sortDirection={() => 'asc'}+ onSort={() => {}}+ expandedKey={null}+ onToggleExpand={() => {}}+ showTaskColumn={true}+ layoutWidth={() => 330}+ />+ ));++ expect(document.body.textContent).toContain('Overdue');+ expect(document.body.textContent).not.toContain('Attn.');+ // The short word is for sighted phone users; assistive tech gets the full+ // state and explanation in its place.+ const word = screen.getByText('Overdue');+ expect(word).toHaveAttribute('aria-hidden', 'true');+ expect(word.parentElement?.querySelector('.sr-only')?.textContent).toMatch(+ /^Needs attention: ./,+ );+ });+it.each([330, 600, 1200])('keeps backup locations readable as locations at %ipx without using them as nodes',(width) => {diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupCounts.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupCounts.test.tsnew file mode 100644index 0000000000..5422388dcc--- /dev/null+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupCounts.test.ts@@ -0,0 +1,38 @@+import { describe, expect, it } from 'vitest';+import {+ describeIncompleteArtifacts,+ restorePointCountNoun,+ type RecoverableArtifact,+} from '../proxmoxBackupRecoveryModel';++const artifact = (flags: { running?: boolean; failed?: boolean } = {}) =>+ flags as RecoverableArtifact;++describe('describeIncompleteArtifacts', () => {+ it.each([+ ['nothing incomplete', [artifact()], ''],+ ['an empty list', [], ''],+ ['running only', [artifact({ running: true }), artifact()], '1 running'],+ ['failed only', [artifact({ failed: true }), artifact({ failed: true })], '2 failed'],+ ['both', [artifact({ running: true }), artifact({ failed: true })], '1 running · 1 failed'],+ [+ 'an entry flagged both, once as running',+ [artifact({ running: true, failed: true })],+ '1 running',+ ],+ ])('describes %s', (_label, artifacts, expected) => {+ expect(describeIncompleteArtifacts(artifacts)).toBe(expected);+ });+});++describe('restorePointCountNoun', () => {+ it.each([+ [1, false, 'restore point'],+ [2, false, 'restore points'],+ [0, false, 'restore points'],+ [1, true, 'restore point read'],+ [2, true, 'restore points read'],+ ])('reads %i with incomplete=%s as %s', (count, incomplete, expected) => {+ expect(restorePointCountNoun(count, incomplete)).toBe(expected);+ });+});diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupVerdict.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupVerdict.test.tsindex d634795ee7..382fdb225c 100644--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupVerdict.test.ts+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupVerdict.test.ts@@ -2,7 +2,11 @@ import { describe, expect, it } from 'vitest';import type { ProtectionPosture } from '@/types/recovery';import { protectionPolicy, protectionPosture } from '@/utils/__fixtures__/protectionPosture';import type { WorkloadCoverageRow, WorkloadRecoveryPosture } from '../proxmoxBackupRecoveryModel';-import { backupExceptionGroupKey, buildBackupVerdict } from '../proxmoxBackupVerdict';+import {+ backupExceptionGroupKey,+ buildBackupVerdict,+ compactBackupReasonLabel,+} from '../proxmoxBackupVerdict';const row = (label: string,@@ -122,3 +126,27 @@ describe('backupExceptionGroupKey', () => {);});});++describe('compactBackupReasonLabel', () => {+ it.each([+ ['attention', 'source-failed', 'Failed'],+ ['unprotected', 'backup-future-dated', 'Bad date'],+ ['attention', 'stale', 'Overdue'],+ ['attention', 'verification-future-dated', 'Bad date'],+ ['attention', 'verification-overdue', 'Verify late'],+ ['unknown', 'history-partial', 'Partial'],+ ['unknown', 'history-unreadable', "Can't read"],+ ['unknown', 'no-history', 'Unknown'],+ ['unprotected', 'snapshots-only', 'Snapshots'],+ ['unprotected', 'no-backup', 'No backup'],+ ] as const)('gives a %s row with reason %s a word for a phone row', (posture, reason, label) => {+ expect(compactBackupReasonLabel(row('guest', posture, reason))).toBe(label);+ });++ it('names no reason it cannot back up', () => {+ expect(compactBackupReasonLabel(row('guest', 'attention'))).toBeNull();+ expect(compactBackupReasonLabel(row('guest', 'attention', 'from-a-newer-server'))).toBeNull();+ expect(compactBackupReasonLabel(row('guest', 'protected', 'stale'))).toBeNull();+ expect(compactBackupReasonLabel(row('guest', 'checking'))).toBeNull();+ });+});diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.tsindex 5abfae231b..9eb635b83d 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts+++ b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts@@ -169,6 +169,23 @@ export function isCompletedRecoveryArtifact(artifact: RecoverableArtifact): boolreturn !artifact.running && !artifact.failed;}+/**+ * What a list holds beyond its completed restore points ("33 running · 1 failed").+ * An entry both running and failed counts once, as running, as its row reads.+ */+export function describeIncompleteArtifacts(artifacts: readonly RecoverableArtifact[]): string {+ const running = artifacts.filter((artifact) => artifact.running).length;+ const failed = artifacts.filter((artifact) => !artifact.running && artifact.failed).length;+ return [running > 0 ? `${running} running` : '', failed > 0 ? `${failed} failed` : '']+ .filter(Boolean)+ .join(' · ');+}++export const restorePointCountNoun = (count: number, inventoryIncomplete: boolean): string => {+ const noun = count === 1 ? 'restore point' : 'restore points';+ return inventoryIncomplete ? `${noun} read` : noun;+};+// Zero is also the producer's missing-size placeholder. Keep it in the raw// inventory, but not as a measured zero in the recovery view (including sorts).function reportedSizeBytes(size: number | undefined): number | undefined {diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupVerdict.ts b/frontend-modern/src/features/proxmox/proxmoxBackupVerdict.tsindex d604a118e2..fd7a369aea 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupVerdict.ts+++ b/frontend-modern/src/features/proxmox/proxmoxBackupVerdict.ts@@ -76,6 +76,26 @@ export const backupExceptionGroupKey = (row: WorkloadCoverageRow): string | nullreturn reason && reasonLabel(reason, null) ? reason : row.posture;};+// A phone row has room for a word or two. The full reason stays in the row's+// title and expansion, and Backup health names it in full.+const COMPACT_REASON_LABEL: Record<string, string> = {+ 'source-failed': 'Failed',+ 'backup-future-dated': 'Bad date',+ stale: 'Overdue',+ 'verification-future-dated': 'Bad date',+ 'verification-overdue': 'Verify late',+ 'history-partial': 'Partial',+ 'history-unreadable': "Can't read",+ 'no-history': 'Unknown',+ 'snapshots-only': 'Snapshots',+ 'no-backup': 'No backup',+};++export const compactBackupReasonLabel = (row: WorkloadCoverageRow): string | null => {+ const key = backupExceptionGroupKey(row);+ return key ? (COMPACT_REASON_LABEL[key] ?? null) : null;+};+const TONE_ORDER: Record<BackupExceptionTone, number> = {unprotected: 0,attention: 1,diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.tsindex 7e794d181f..b9918688d3 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts+++ b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts@@ -157,7 +157,7 @@ const COVERAGE_WEIGHTS: Record<ProxmoxBackupsTableLayoutMode,Partial<Record<CoverageColumnId, number>>> = {- // Posture keeps its whole compact word ("Unknown"), the age cell holds the+ // Posture keeps its whole compact reason word, the age cell holds the// suffix-free compact age, and the job dot takes what a "Job" header needs.compact: { workload: 46, posture: 22, latest: 18, task: 14 },// Above the phone projection the identity columns (workload, node) take the@@ -196,10 +196,11 @@ export const getCoverageColumns = (// Coverage's phone rows carry only the name in their identity cell, and guest// names often share a long prefix ("checkout-web-110"), so cutting their ends// hides what tells them apart. The cells beside it hold short, fixed content,-// measured at 320px: "Unknown" with its dot, an "Unknown" age, the job dot-// under "Job". When the table knows its width they take exactly that and the-// name takes the rest, instead of a fixed share that wastes room at 360px and-// up. A 302px table still leaves the other cells whole.+// measured at 320px: a reason word with its dot ("No backup" is the longest),+// an "Unknown" age, the job dot under "Job". When the table knows its width+// they take exactly that and the name takes the rest, instead of a fixed share+// that wastes room at 360px and up. A 302px table still leaves the other cells+// whole.const COVERAGE_COMPACT_CELL_WIDTH_PX: Partial<Record<CoverageColumnId, number>> = {posture: 80,latest: 52,