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 phone guest names separate from backup controls and locks
pulse-triage[bot]aff24f6dbc7d
diff --git a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.mdindex ef8be3984f..6bd98740cc 100644--- a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md+++ b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md@@ -8,6 +8,20 @@ A gate is only `passed` when its automated proof still passes and the manualscenario has been exercised in a staging-like environment with the expectedresult.+## Workloads locked-guest identity on phones++Automated: `GuestRow.test.tsx` lock-label cases and+`frontend-modern/browser-tests/guest-row-lock-identity.cjs` after precompiling+with `node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`. The parent+row is the exact own-parent source, not a replay of a terminated preview. Inspect the real+name, status/backup indicator, full lock and visible memory-freshness cue at+320 and 390 px in light/dark bars and sparklines. The backup evidence control sits below the name on phones without shrinking+its touch target; the lock remains separately visible. Long locks wrap inside the identity cell and long names retain their full title.+Check that desktop keyboard Enter and the first phone touch open the same guest,+that drawer safety copy stays intact, and that lock transitions on the same row+do not renew the original memory timestamp. Wider rows keep their inline layout.+This fixture uses synthetic data, not installed/native guest recovery proof.+## Workloads memory observation presentationAutomated: `GuestRow.test.tsx` (memory observation provenance),diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex d79ce3fffc..4d5684a764 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+### Narrow Workloads identity during guest locks++In narrow and phone layouts, the guest name and status occupy the first line;+the unchanged backup evidence control moves below the name, retaining its+44 px touch target. The guest lock occupies a separate, wrapping line below+that identity. It must not consume the name's+horizontal space or spill into the adjacent metrics. The full lock remains+visible; a long name keeps its full title and existing truncation. Wider layouts+keep the inline lock. Disclosure, first-touch row activation and memory+observation source/time are unchanged. This is presentation only: a backup lock+or successful backup never proves guest recovery.++`GuestRow.test.tsx` checks layout structure, lock updates and existing action+ownership. `browser-tests/build-guest-row-lock-fixture.mjs` compiles the real row,+stylesheet and drawer before bounded static browser execution. Use+`node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`+to read the exact parent row from Git; no manually supplied control is accepted.+`browser-tests/guest-row-lock-identity.cjs` measures the rendered name/lock at 320 and 390 px in bars and sparklines, and exercises keyboard/first+touch through the existing drawer, checks long-name bounds, and rejects the current+parent with the same static fixture. No dev compiler or old terminated preview+is replayed. Native recovery remains separate.+### Confirmed operations opt out of silent transport fallbackThe shared API client accepts expectedOrgID and retry:false for confirmeddiff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex 0079c57c59..7641da0d28 100644--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md@@ -15,6 +15,28 @@## Purpose+### Narrow Workloads identity during guest locks++In narrow and phone layouts, the guest name and status occupy the first line;+the unchanged backup evidence control moves below the name, retaining its+44 px touch target. The guest lock occupies a separate, wrapping line below+that identity. It must not consume the name's+horizontal space or spill into the adjacent metrics. The full lock remains+visible; a long name keeps its full title and existing truncation. Wider layouts+keep the inline lock. Disclosure, first-touch row activation and memory+observation source/time are unchanged. This is presentation only: a backup lock+or successful backup never proves guest recovery.++`GuestRow.test.tsx` checks layout structure, lock updates and existing action+ownership. `browser-tests/build-guest-row-lock-fixture.mjs` compiles the real row,+stylesheet and drawer before bounded static browser execution. Use+`node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`+to read the exact parent row from Git; no manually supplied control is accepted.+`browser-tests/guest-row-lock-identity.cjs` measures the rendered name/lock at 320 and 390 px in bars and sparklines, and exercises keyboard/first+touch through the existing drawer, checks long-name bounds, and rejects the current+parent with the same static fixture. No dev compiler or old terminated preview+is replayed. Native recovery remains separate.+**Memory freshness is preserved at the Workloads row boundary.**`GuestRow.tsx` qualifies selected memory once per reactive reading using thediff --git a/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjs b/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjsnew file mode 100644index 0000000000..40447f29dc--- /dev/null+++ b/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjs@@ -0,0 +1,110 @@+// Compile the existing real-row/drawer fixture once, before bounded browser execution.+// No dev compiler, App, guest request or installer runs inside the browser tree.+import { build } from 'vite';+import solid from 'vite-plugin-solid';+import tailwindcss from '@tailwindcss/vite';+import { stop } from 'esbuild';+import fs from 'node:fs';+import path from 'node:path';+import crypto from 'node:crypto';+import { fileURLToPath } from 'node:url';+import { execFileSync } from 'node:child_process';++const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');+const output = path.resolve(root, '../tmp/guest-row-lock-static');+const row = path.join(root, 'src/components/Workloads/GuestRow.tsx');+const parentRow = path.join(output, 'parent-row.tsx');+const hash = (data) => crypto.createHash('sha256').update(data).digest('hex');+const parentOnly = process.argv.includes('--with-parent');+const parentIndex = process.argv.indexOf('--parent');+const parentSha = parentIndex < 0 ? undefined : process.argv[parentIndex + 1];+if (parentOnly) {+ if (!/^[a-f0-9]{40}$/.test(parentSha ?? '')) {+ throw new Error('--with-parent requires --parent <exact 40-character parent SHA>');+ }+ fs.mkdirSync(output, { recursive: true });+ fs.writeFileSync(+ parentRow,+ execFileSync(+ 'git',+ ['show', `${parentSha}:frontend-modern/src/components/Workloads/GuestRow.tsx`],+ { cwd: root },+ ),+ );+}++try {+ for (const variant of parentOnly ? ['parent', 'final'] : ['final']) {+ const sources = {};+ const artifacts = {};+ const outDir = path.join(output, variant);+ await build({+ root,+ // Both variants are served below their own prefix, including nested HTML.+ base: './',+ configFile: false,+ publicDir: false,+ plugins: [+ {+ name: 'exact-guest-row-fixture-binding',+ enforce: 'pre',+ load(id) {+ if (variant === 'parent' && id === row) return fs.readFileSync(parentRow, 'utf8');+ },+ generateBundle(_options, bundle) {+ for (const id of this.getModuleIds()) {+ if (!id.startsWith(root + '/') || id.includes('/node_modules/')) continue;+ const file = id.split('?')[0];+ if (!fs.existsSync(file) || !fs.statSync(file).isFile()) continue;+ sources[path.relative(root, file)] = hash(+ fs.readFileSync(variant === 'parent' && file === row ? parentRow : file),+ );+ }+ for (const [file, asset] of Object.entries(bundle)) {+ artifacts[file] = hash(asset.type === 'chunk' ? asset.code : asset.source);+ }+ },+ },+ tailwindcss(),+ solid(),+ ],+ resolve: {+ alias: { '@': path.join(root, 'src') },+ conditions: ['import', 'browser', 'default'],+ },+ build: {+ // Match the application's declared target, not Vite's older default.+ target: 'esnext',+ outDir,+ emptyOutDir: true,+ rollupOptions: { input: path.join(root, 'browser-tests/guest-row-memory-provenance.html') },+ },+ });+ // Hash the bytes actually written, including HTML post-processing.+ const walk = (dir) => {+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {+ const file = path.join(dir, entry.name);+ if (entry.isDirectory()) walk(file);+ else artifacts[path.relative(outDir, file)] = hash(fs.readFileSync(file));+ }+ };+ walk(outDir);+ fs.writeFileSync(+ path.join(outDir, 'binding.json'),+ JSON.stringify(+ {+ variant,+ ...(variant === 'parent' ? { parent_sha: parentSha } : {}),+ graph: hash(fs.readFileSync(path.join(root, 'package-lock.json'))),+ builder: hash(fs.readFileSync(fileURLToPath(import.meta.url))),+ sources,+ artifacts,+ },+ null,+ 2,+ ) + '\n',+ );+ }+} finally {+ stop();+}diff --git a/frontend-modern/browser-tests/guest-row-lock-identity.cjs b/frontend-modern/browser-tests/guest-row-lock-identity.cjsnew file mode 100644index 0000000000..d4982dc0d2--- /dev/null+++ b/frontend-modern/browser-tests/guest-row-lock-identity.cjs@@ -0,0 +1,341 @@+// Precompiled production GuestRow/CSS/drawer fixture, not a live guest or full App.+const assert = require('node:assert/strict');+const fs = require('node:fs');+const path = require('node:path');+const crypto = require('node:crypto');+const { chromium, webkit } = require('playwright');+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');+const root = '/workspace/frontend-modern';+const output = '/workspace/tmp/guest-row-lock-identity';+const compiled = '/workspace/tmp/guest-row-lock-static';+const http = require('node:http');+const origin = 'http://127.0.0.1:5334';+fs.mkdirSync(output, { recursive: true });+const result = {+ result: 'incomplete',+ playwright: require('playwright/package.json').version,+ binding: {+ builder: hash(root + '/browser-tests/build-guest-row-lock-fixture.mjs'),+ runtime: hash(root + '/src/components/Workloads/GuestRow.tsx'),+ stylesheet: hash(root + '/src/index.css'),+ fixture: hash(root + '/browser-tests/guest-row-memory-provenance.tsx'),+ script: hash(root + '/browser-tests/guest-row-lock-identity.cjs'),+ graph: hash(root + '/package-lock.json'),+ },+ cases: [],+ captures: [],+ cleanup: {},+ limits:+ 'Production GuestRow, source stylesheet, actual drawer and existing synthetic memory/History fixture in a precompiled static bundle. No full App or production-build browser claim, native QGA, thaw/writes/liveness/restoration, installed/release/reporter or physical-device acceptance.',+};+assert.equal(+ result.playwright,+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[+ 'node_modules/@playwright/test'+ ].version,+);+(async () => {+ const bindings = {};+ for (const variant of ['parent', 'final']) {+ const dir = path.join(compiled, variant);+ const binding = JSON.parse(fs.readFileSync(path.join(dir, 'binding.json')));+ assert.equal(binding.graph, hash(root + '/package-lock.json'));+ assert.equal(binding.builder, hash(root + '/browser-tests/build-guest-row-lock-fixture.mjs'));+ for (const [file, digest] of Object.entries(binding.artifacts))+ assert.equal(hash(path.join(dir, file)), digest, 'served artifact matches compiler output');+ for (const [file, digest] of Object.entries(binding.sources))+ assert.equal(+ hash(+ variant === 'parent' && file === 'src/components/Workloads/GuestRow.tsx'+ ? path.join(compiled, 'parent-row.tsx')+ : path.join(root, file),+ ),+ digest,+ 'every imported source byte matches its binding',+ );+ bindings[variant] = binding;+ }+ result.compiled = bindings;+ const server = http.createServer((req, res) => {+ const pathname = new URL(req.url, origin).pathname;+ const file = path.resolve(compiled, '.' + pathname);+ if (!file.startsWith(compiled + '/') || !fs.existsSync(file) || !fs.statSync(file).isFile()) {+ res.writeHead(404);+ res.end();+ return;+ }+ const ext = path.extname(file);+ res.setHeader(+ 'Content-Type',+ ext === '.html'+ ? 'text/html'+ : ext === '.js'+ ? 'application/javascript'+ : ext === '.css'+ ? 'text/css'+ : 'application/octet-stream',+ );+ res.end(fs.readFileSync(file));+ });+ await new Promise((resolve, reject) => {+ server.once('error', reject);+ server.listen(5334, '127.0.0.1', resolve);+ });+ let browser;+ try {+ for (const [name, engine, width, dark] of [+ ['parent-control', webkit, 320, false],+ ['narrow-light', webkit, 320, false],+ ['phone-dark', webkit, 390, true],+ ['narrow-dark-chromium', chromium, 320, true],+ ['phone-light-chromium', chromium, 390, false],+ ['desktop-light', chromium, 1365, false],+ ['desktop-dark', chromium, 1365, true],+ ]) {+ browser = await engine.launch(+ engine === chromium+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }+ : { headless: true },+ );+ const context = await browser.newContext({+ viewport: { width, height: width <= 768 ? 844 : 900 },+ isMobile: width <= 768,+ hasTouch: width <= 768,+ locale: 'en-GB',+ timezoneId: 'UTC',+ reducedMotion: 'reduce',+ });+ const page = await context.newPage();+ page.setDefaultTimeout(7000);+ const record = {+ name,+ width,+ dark,+ browser: browser.version(),+ checks: [],+ errors: [],+ requests: [],+ };+ result.cases.push(record);+ page.on('pageerror', (error) => record.errors.push(error.message));+ page.on('response', (response) => {+ if (response.status() >= 400) record.errors.push(`${response.status()} ${response.url()}`);+ });+ await page.route('**/*', (route) => {+ const url = new URL(route.request().url());+ assert.equal(url.origin, origin, 'no external access');+ if (!url.pathname.startsWith('/api/')) return route.continue();+ assert.equal(route.request().method(), 'GET');+ assert(!/diagnostics|\/run|guest-agent|qemu/.test(url.pathname));+ record.requests.push(url.pathname);+ return route.fulfill({+ json: { success: true, data: [], alerts: [], anomalies: [], config: null },+ });+ });+ await page.addInitScript(+ (value) =>+ document.addEventListener('DOMContentLoaded', () =>+ document.documentElement.classList.toggle('dark', value),+ ),+ dark,+ );+ await page.goto(+ origin ++ (name === 'parent-control' ? '/parent' : '/final') ++ '/browser-tests/guest-row-memory-provenance.html',+ {+ timeout: 10000,+ waitUntil: 'domcontentloaded',+ },+ );+ const row = page.locator('[data-guest-id="fixture:pve1:101"]');+ const cell = row.locator('[data-workload-col="name"]');+ const notice = row.locator('[data-workload-memory-read-status]');+ await notice.waitFor();+ const identity = await row.elementHandle();+ const capture = async (state) => {+ const file = `${name}-${state}.png`;+ await page.screenshot({ path: path.join(output, file), fullPage: true });+ result.captures.push({ file, sha256: hash(path.join(output, file)) });+ };+ const geometry = async (guestName = 'backup-guest', lock = 'backup') =>+ cell.evaluate(+ (cell, values) => {+ const name = [...cell.querySelectorAll('[title]')].find(+ (el) => el.title === values.guestName,+ );+ const badge = [...cell.querySelectorAll('[title]')].find(+ (el) => el.title === `Guest is locked (${values.lock})`,+ );+ const box = (el) => {+ const r = el.getBoundingClientRect();+ return {+ x: r.x,+ y: r.y,+ width: r.width,+ height: r.height,+ right: r.right,+ bottom: r.bottom,+ };+ };+ return {+ cell: box(cell),+ name: box(name),+ nameWidth: name.clientWidth,+ nameScrollWidth: name.scrollWidth,+ lock: box(badge),+ lockWidth: badge.clientWidth,+ lockScrollWidth: badge.scrollWidth,+ };+ },+ { guestName, lock },+ );+ const g = await geometry();+ record.geometry = g;+ await capture('backup-bars');+ if (name === 'parent-control') {+ assert(g.nameWidth < g.nameScrollWidth - 1, 'current parent reproduces clipped guest name');+ record.checks.push('same static fixture rejects current parent: ordinary name clipped');+ await context.close();+ await browser.close();+ browser = undefined;+ record.closed = true;+ continue;+ }+ assert(g.nameWidth >= g.nameScrollWidth - 1, 'ordinary guest name remains readable');+ assert(+ g.lock.x >= g.cell.x && g.lock.right <= g.cell.right + 1,+ 'complete lock fits its cell',+ );+ assert(g.lockScrollWidth <= g.lockWidth + 1, 'lock is not clipped');+ if (width <= 768)+ assert(g.lock.y >= g.name.bottom, 'lock is below, not competing with identity');+ assert((await notice.textContent()).includes('Not a current measurement'));+ assert((await notice.locator('.sr-only').textContent()).includes('2026-09-30 11:00:00 UTC'));+ assert(+ await notice+ .locator('[aria-hidden="true"]')+ .getByText(width <= 768 ? 'Prior' : 'Last known', { exact: true })+ .isVisible(),+ );+ record.checks.push(+ 'ordinary name, full backup lock and original memory freshness fit without hover',+ );+ await page.getByLabel('Metric display').selectOption('sparklines');+ await row+ .getByRole('img', { name: 'backup-guest memory history, last known 25%', exact: true })+ .waitFor();+ assert.equal((await geometry()).nameWidth, g.nameWidth);+ if (name === 'phone-dark') await capture('backup-sparkline');+ record.checks.push(+ 'sparkline mode retains the same readable identity/lock and last-known value',+ );+ await page.getByLabel('Metric display').selectOption('bars');+ const backupControl = cell.getByRole('button', { name: 'No backup found', exact: true });+ const backupBounds = await backupControl.boundingBox();+ assert(backupBounds.width >= 44 || width > 768, 'phone backup target retains 44 px width');+ assert(backupBounds.height >= 44 || width > 768, 'phone backup target retains 44 px height');+ assert(backupBounds.x >= g.cell.x && backupBounds.x + backupBounds.width <= g.cell.right + 1);+ if (width <= 768) await backupControl.tap();+ else await backupControl.click();+ const backupDialog = page.getByRole('dialog', {+ name: 'Backup status details for backup-guest',+ exact: true,+ });+ await backupDialog.waitFor();+ assert((await backupDialog.textContent()).includes('No completed backup found'));+ assert.equal(await page.getByRole('region', { name: 'Guest details' }).count(), 0);+ if (name === 'narrow-light') await capture('backup-evidence-dialog');+ await backupDialog.getByRole('button', { name: 'Close backup details', exact: true }).click();+ record.checks.push(+ 'backup control retains its touch target and opens only same-guest completion evidence',+ );+ if (width <= 768) await cell.getByText('backup-guest', { exact: true }).tap();+ else {+ await page.getByLabel('Metric display').focus();+ for (let i = 0; i < 2; i++) await page.keyboard.press('Tab');+ assert(+ await row+ .getByRole('button', { name: 'Expand backup-guest', exact: true })+ .evaluate((el) => document.activeElement === el),+ );+ await page.keyboard.press('Enter');+ }+ const details = page.getByRole('region', { name: 'Guest details' });+ await details.waitFor();+ assert((await details.getByText('backup-guest', { exact: true }).count()) > 0);+ const precaution = await details.getByTestId('guest-read-precaution').textContent();+ assert(precaution.includes('Do not run live diagnostics or restart the guest agent'));+ assert(precaution.includes('An OK backup or a running VM does not prove thaw'));+ assert(+ precaution.includes(+ 'Confirm thaw and writes to the filesystems covered by the backup independently',+ ),+ );+ assert((await details.textContent()).includes('Last known'));+ if (name === 'phone-dark') await capture('same-guest-drawer');+ await details+ .getByRole('button', { name: 'Collapse backup-guest details', exact: true })+ .click();+ assert.equal(await details.count(), 0);+ record.checks.push(+ 'first touch or real keyboard Enter opens the same guest and preserves recovery precaution; collapse works',+ );+ await page.evaluate(() =>+ window.__memoryRow.update({+ name: 'long-backup-guest-identity-101',+ lock: 'snapshot-delete',+ backupInProgress: true,+ }),+ );+ const long = await geometry('long-backup-guest-identity-101', 'snapshot-delete');+ assert(long.name.width > 20, 'long identity must not disappear');+ if (width <= 768) {+ assert(+ long.nameScrollWidth > long.nameWidth,+ 'long phone name truncates with its full title',+ );+ }+ assert(+ long.lock.right <= long.cell.right + 1 && long.lockScrollWidth <= long.lockWidth + 1,+ 'long lock wraps inside identity cell',+ );+ if (name === 'narrow-light') await capture('long-identity-lock');+ record.longGeometry = long;+ await page.evaluate(() =>+ window.__memoryRow.update({+ name: 'backup-guest',+ lock: '',+ backupInProgress: false,+ lastSeen: '2026-10-06T10:00:00Z',+ }),+ );+ assert.equal(await cell.locator('[title^="Guest is locked"]').count(), 0);+ assert((await notice.textContent()).includes('2026-09-30 11:00:00 UTC'));+ assert(await identity.evaluate((el) => el.isConnected));+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth));+ assert.deepEqual(record.errors, []);+ record.checks.push(+ 'same mounted row updates/removes locks without renewing memory; long identity stays titled, no page overflow/errors',+ );+ await context.close();+ await browser.close();+ browser = undefined;+ record.closed = true;+ }+ result.result = 'passed';+ } catch (error) {+ result.error = error.message;+ throw error;+ } finally {+ if (browser) await browser.close();+ result.cleanup.browser_closed = true;+ await new Promise((resolve) => server.close(resolve));+ result.cleanup.compiler_not_started = true;+ result.cleanup.server_closed = true;+ fs.writeFileSync(output + '/result.json', JSON.stringify(result, null, 2));+ }+})().catch((error) => {+ console.error(error);+ process.exitCode = 1;+});diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsxindex 18bcd14244..7b09f1bcee 100644--- a/frontend-modern/src/components/Workloads/GuestRow.tsx+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx@@ -350,51 +350,60 @@ export function GuestRow(props: GuestRowProps) {onPreviewClear={() => props.onHoverChange?.(null)}/></Show>- <div class="flex items-center gap-1.5 min-w-0">- <StatusDot- variant={guestStatus().variant}- title={guestStatus().label}- ariaLabel={guestStatus().label}- size="xs"- />- <div class="flex items-center gap-1.5 min-w-0 group/name">- <ResourceNameWithWebInterfaceLink- name={props.guest.name}- url={customUrl()}- class={`min-w-0 ${usesCondensedIdentity() ? '[&>a]:hidden' : ''}`}- nameClass="truncate text-[11px] font-medium text-base-content select-none"+ <div+ class={`min-w-0 ${usesCondensedIdentity() ? 'flex flex-1 flex-col items-start gap-0.5' : 'flex items-center gap-2'}`}+ >+ <div+ class={`flex items-center gap-1.5 min-w-0 ${usesCondensedIdentity() ? 'w-full' : ''}`}+ >+ <StatusDot+ variant={guestStatus().variant}+ title={guestStatus().label}+ ariaLabel={guestStatus().label}+ size="xs"+ class={usesCondensedIdentity() ? 'self-start mt-1.5' : undefined}/>- {/* Show backup indicator in name cell only if backup column is hidden */}- <Show when={!isColVisible('backup') && supportsBackup()}>- <BackupIndicator- guestName={props.guest.name}- lastBackup={props.guest.lastBackup}- isTemplate={props.guest.template}- backupRunning={props.guest.backupInProgress}+ <div+ class={`min-w-0 group/name ${usesCondensedIdentity() ? 'flex flex-1 flex-col items-start gap-0.5' : 'flex items-center gap-1.5'}`}+ >+ <ResourceNameWithWebInterfaceLink+ name={props.guest.name}+ url={customUrl()}+ class={`min-w-0 ${usesCondensedIdentity() ? 'w-full [&>a]:hidden' : ''}`}+ nameClass="truncate text-[11px] font-medium text-base-content select-none"/>- </Show>- <Show when={nestedWorkloadCueLabel()}>- <span- class="inline-flex shrink-0 items-center gap-0.5 text-[10px] font-medium leading-none text-muted"- data-testid="nested-workload-cue"- title={nestedWorkloadCueLabel()}- aria-label={nestedWorkloadCueLabel()}- >- <BoxIcon class="h-3 w-3" aria-hidden="true" />- <span class="tabular-nums">{props.nestedWorkloadContext?.count}</span>- </span>- </Show>+ {/* Show backup indicator in name cell only if backup column is hidden */}+ <Show when={!isColVisible('backup') && supportsBackup()}>+ <BackupIndicator+ guestName={props.guest.name}+ lastBackup={props.guest.lastBackup}+ isTemplate={props.guest.template}+ backupRunning={props.guest.backupInProgress}+ />+ </Show>+ <Show when={nestedWorkloadCueLabel()}>+ <span+ class="inline-flex shrink-0 items-center gap-0.5 text-[10px] font-medium leading-none text-muted"+ data-testid="nested-workload-cue"+ title={nestedWorkloadCueLabel()}+ aria-label={nestedWorkloadCueLabel()}+ >+ <BoxIcon class="h-3 w-3" aria-hidden="true" />+ <span class="tabular-nums">{props.nestedWorkloadContext?.count}</span>+ </span>+ </Show>+ </div></div>- </div>- <Show when={lockLabel()}>- <span- class="text-[10px] font-medium text-muted uppercase tracking-wide whitespace-nowrap"- title={`Guest is locked (${lockLabel()})`}- >- Lock: {lockLabel()}- </span>- </Show>+ <Show when={lockLabel()}>+ <span+ class={`max-w-full text-[10px] font-medium text-muted uppercase tracking-wide ${usesCondensedIdentity() ? 'whitespace-normal break-words' : 'whitespace-nowrap'}`}+ title={`Guest is locked (${lockLabel()})`}+ >+ Lock: {lockLabel()}+ </span>+ </Show>+ </div></div></td>diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsxindex 9febd0c100..9257c215c0 100644--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx@@ -1196,6 +1196,79 @@ describe('GuestRow', () => {expect(screen.getByText(/Lock:.*migrate/)).toBeTruthy();});+ it.each(['narrow', 'phone'] as const)(+ 'keeps a %s lock below the identity without changing row activation',+ (layout) => {+ const onClick = vi.fn();+ const { container } = renderGuestRow({+ guest: makeGuest({ name: 'backup-guest', lock: 'backup' }),+ workloadTableLayoutMode: layout,+ onClick,+ });+ const lock = screen.getByTitle('Guest is locked (backup)');+ const name = screen.getByText('backup-guest');+ expect(lock.parentElement).toHaveClass('flex-col', 'items-start', 'min-w-0');+ expect(lock.parentElement).toContainElement(name);+ expect(name.parentElement).toHaveClass('w-full');+ expect(name.parentElement?.parentElement).toHaveClass('flex-col', 'items-start');+ expect(name.parentElement?.parentElement?.parentElement).toHaveClass('w-full');+ expect(lock).toHaveClass('whitespace-normal', 'break-words', 'max-w-full');+ expect(lock).not.toHaveAttribute('tabindex');+ fireEvent.click(lock);+ expect(onClick).toHaveBeenCalledTimes(1);+ fireEvent.keyDown(screen.getByRole('button', { name: 'Expand backup-guest' }), {+ key: 'Enter',+ });+ expect(onClick).toHaveBeenCalledTimes(2);+ expect(container.querySelector('tr')).not.toHaveAttribute('tabindex');+ },+ );++ it.each(['mobile', 'tablet', 'compact', 'wide'] as const)(+ 'preserves inline identity and lock at the %s table layout',+ (layout) => {+ renderGuestRow({+ guest: makeGuest({ lock: 'migrate' }),+ workloadTableLayoutMode: layout,+ });+ const lock = screen.getByTitle('Guest is locked (migrate)');+ expect(lock.parentElement).toHaveClass('items-center');+ expect(lock.parentElement).not.toHaveClass('flex-col');+ expect(lock).toHaveClass('whitespace-nowrap');+ },+ );++ it('updates a lock on the same guest without renewing retained memory', () => {+ const initial = makeGuest({+ lock: 'backup',+ memory: makeMemory({+ observation: {+ state: 'last-known',+ source: 'guest-agent-meminfo',+ observedAt: '2026-09-30T11:00:00Z',+ },+ }),+ });+ const [guest, setGuest] = createSignal(initial);+ const { container } = render(() => (+ <table>+ <tbody>+ <GuestRow guest={guest()} workloadTableLayoutMode="phone" />+ </tbody>+ </table>+ ));+ const row = container.querySelector('tr');+ const notice = container.querySelector('[data-workload-memory-read-status]');+ expect(notice).toHaveTextContent('2026-09-30 11:00:00 UTC');+ setGuest({ ...initial, lock: 'snapshot-delete' });+ expect(screen.getByTitle('Guest is locked (snapshot-delete)')).toBeVisible();+ setGuest({ ...initial, lock: '', lastSeen: '2026-10-06T10:00:00Z' });+ expect(screen.queryByTitle('Guest is locked (snapshot-delete)')).toBeNull();+ expect(container.querySelector('tr')).toBe(row);+ expect(container.querySelector('[data-workload-memory-read-status]')).toBe(notice);+ expect(notice).toHaveTextContent('2026-09-30 11:00:00 UTC');+ });+it('does not show lock label when not locked', () => {renderGuestRow({ guest: makeGuest({ lock: '' }) });expect(screen.queryByText('Lock:')).toBeNull();