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 Discovery outcomes attached to their guest and run
pulse-triage[bot]817834440b3d
diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.cjs b/frontend-modern/browser-tests/discovery-outcome-ownership.cjsnew file mode 100644index 0000000000..3d7238fbab--- /dev/null+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.cjs@@ -0,0 +1,301 @@+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 root = '/workspace/frontend-modern';+const output = '/workspace/tmp/discovery-ownership-proof/browser';+const origin = 'http://127.0.0.1:5333';+const runtime = [+ 'frontend-modern/src/components/Discovery/DiscoveryTab.tsx',+ 'frontend-modern/src/components/Discovery/useDiscoveryTabState.ts',+ 'frontend-modern/src/components/Workloads/GuestDrawer.tsx',+];+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');+const saved = (id, service = `Saved Home Assistant ${id}`) => ({+ id: `vm:fixture-node-agent:${id}`,+ resource_type: 'vm',+ resource_id: id,+ target_id: 'fixture-node-agent',+ hostname: `guest-${id}`,+ service_type: 'home-assistant',+ service_name: service,+ service_version: 'test',+ category: 'home_automation',+ cli_access: '',+ facts: [],+ config_paths: [],+ data_paths: [],+ log_paths: [],+ ports: [],+ user_notes: '',+ user_secrets: {},+ confidence: 0.9,+ ai_reasoning: 'Synthetic saved evidence',+ discovered_at: '2026-10-03T12:00:00Z',+ updated_at: '2026-10-03T12:00:00Z',+ discovery_engine_version: 1,+});+(async () => {+ fs.mkdirSync(output, { recursive: true });+ const report = {+ result: 'incomplete',+ playwright: require('playwright/package.json').version,+ runtime_sha256: Object.fromEntries(runtime.map((p) => [p, hash('/workspace/' + p)])),+ groups: [],+ screenshots: [],+ cleanup: {},+ limits:+ 'Production DiscoveryTab/state/CSS, synthetic API and production event-bus progress. No native QGA, automatic collector, original freeze cause, thaw, covered filesystem writes, installed, physical-phone or release acceptance.',+ };+ assert.equal(+ report.playwright,+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[+ 'node_modules/@playwright/test'+ ].version,+ );+ process.chdir(root);+ const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));+ const server = await createServer({+ root,+ configFile: path.join(root, 'vite.config.ts'),+ cacheDir: output + '/cache',+ server: { host: '127.0.0.1', port: 5333, strictPort: true, watch: null },+ });+ let browser,+ phase = 'server';+ try {+ await server.listen();+ for (const [name, engine, width, dark] of [+ ['desktop-light', chromium, 1365, false],+ ['desktop-dark', chromium, 1365, true],+ ['phone-dark', webkit, 390, true],+ ['narrow-light', webkit, 320, false],+ ]) {+ phase = name;+ browser = await engine.launch(+ engine === chromium+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }+ : { headless: true },+ );+ const page = await browser.newPage({+ viewport: { width, height: width < 500 ? 844 : 900 },+ isMobile: width < 500,+ hasTouch: width < 500,+ locale: 'en-GB',+ timezoneId: 'UTC',+ });+ page.setDefaultTimeout(10000);+ page.setDefaultNavigationTimeout(60000);+ const group = {+ name,+ width,+ dark,+ browser: browser.version(),+ checks: [],+ requests: [],+ errors: [],+ offOrigin: [],+ };+ report.groups.push(group);+ page.on('pageerror', (error) => group.errors.push(error.message));+ await page.routeWebSocket('**/ws*', () => {});+ await page.addInitScript((dark) => {+ const apply = () => document.documentElement.classList.toggle('dark', dark);+ if (document.documentElement) apply();+ else document.addEventListener('DOMContentLoaded', apply, { once: true });+ }, dark);+ let fail = false;+ const releases = new Map();+ const arrivals = new Map();+ const stored = new Map();+ await page.route('**/*', async (route) => {+ const request = route.request(),+ url = new URL(request.url());+ if (url.origin !== origin) {+ group.offOrigin.push(url.origin);+ return route.abort();+ }+ if (!url.pathname.startsWith('/api/')) return route.continue();+ group.requests.push({+ path: url.pathname,+ method: request.method(),+ body: request.postData(),+ });+ const target = url.pathname.match(/^\/api\/discovery\/vm\/fixture-node-agent\/(101|102)$/);+ if (target) {+ const id = target[1];+ if (request.method() === 'GET')+ return route.fulfill({ json: stored.get(id) || saved(id) });+ assert.equal(request.method(), 'POST');+ if (fail)+ return route.fulfill({+ status: 409,+ json: { error: 'Guest execution paused: backup lock observed' },+ });+ await new Promise((resolve) => {+ releases.set(id, resolve);+ arrivals.get(id)?.();+ });+ const result = saved(id, id === '101' ? 'Old guest result' : 'Current guest result');+ stored.set(id, result);+ return route.fulfill({ json: result });+ }+ assert.equal(request.method(), 'GET');+ const responses = {+ '/api/discovery/info/vm': {+ ai_provider: { provider: 'test', model: 'test', is_local: true, label: 'Local' },+ commands: [],+ command_categories: [],+ },+ '/api/ai/agents': {+ count: 1,+ agents: [{ agent_id: 'fixture-node-agent', hostname: 'pve1' }],+ },+ '/api/ai/settings': { discovery_enabled: true, enabled: false },+ '/api/license/runtime-capabilities': {+ capabilities: [],+ limits: [],+ hosted_mode: false,+ runtime: { build: 'community' },+ blocked_capabilities: [],+ },+ };+ return route.fulfill({ json: responses[url.pathname] || {} });+ });+ const capture = async (suffix) => {+ await page.screenshot({ path: `${output}/${name}-${suffix}.png`, fullPage: true });+ report.screenshots.push(`${name}-${suffix}.png`);+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1));+ };+ const emit = (progress) =>+ page.evaluate((progress) => window.discoveryOwnership.progress(progress), progress);+ const run = page.getByRole('button', { name: 'Run Discovery', exact: true });+ const pressRun = async () => {+ if (width >= 500) {+ await run.focus();+ await page.keyboard.press('Enter');+ } else await run.tap();+ };+ await page.goto(origin + '/browser-tests/discovery-outcome-ownership.html');+ await page.getByText('Saved Home Assistant 101', { exact: true }).waitFor();+ await run.waitFor();+ await page.waitForFunction(+ () =>+ !Array.from(document.querySelectorAll('button')).find(+ (b) => b.textContent.trim() === 'Run Discovery',+ ).disabled,+ );+ const before = group.requests.length;+ await emit({+ resource_id: 'vm:fixture-node-agent:101',+ status: 'running',+ current_step: 'Collecting guest evidence',+ percent_complete: 20,+ });+ await page.getByText('Collecting guest evidence', { exact: true }).waitFor();+ await emit({+ resource_id: 'vm:fixture-node-agent:101',+ status: 'completed',+ error: 'Guest execution paused: backup lock observed',+ current_step: 'Guest execution paused',+ percent_complete: 20,+ });+ const alert = page.getByRole('alert');+ await alert.waitFor();+ await page.waitForTimeout(650);+ assert((await alert.innerText()).includes('Guest execution paused: backup lock observed'));+ assert.equal(group.requests.length, before);+ assert(await page.getByText('Saved Home Assistant 101', { exact: true }).isVisible());+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);+ await capture('retained-background-pause');+ group.checks.push(+ 'Background completed-with-error remains an accessible failure with saved evidence and no retry or refresh',+ );+ const dismiss = page.getByRole('button', { name: 'Dismiss Discovery error' });+ await dismiss.focus();+ await page.keyboard.press('Enter');+ assert.equal(await alert.count(), 0);+ group.checks.push('The error dismiss action has a keyboard-accessible name');+ const firstPost = new Promise((resolve) => arrivals.set('101', resolve));+ await pressRun();+ await firstPost;+ await page.waitForFunction(() => document.body.textContent.includes('Scanning...'));+ await page.evaluate(() => window.discoveryOwnership.target('102'));+ await page.getByText('Saved Home Assistant 102', { exact: true }).waitFor();+ const secondPost = new Promise((resolve) => arrivals.set('102', resolve));+ await pressRun();+ await secondPost;+ await page.waitForFunction(() => document.body.textContent.includes('Scanning...'));+ assert(releases.has('101'));+ assert(releases.has('102'));+ releases.get('101')();+ await page.waitForTimeout(150);+ assert.equal(await page.getByText('Old guest result', { exact: true }).count(), 0);+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);+ assert(await page.getByRole('button', { name: 'Scanning...', exact: true }).isDisabled());+ await emit({+ resource_id: 'vm:fixture-node-agent:102',+ status: 'completed',+ percent_complete: 100,+ });+ assert(await page.getByRole('button', { name: 'Scanning...', exact: true }).isDisabled());+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);+ releases.get('102')();+ await page.getByText('Current guest result', { exact: true }).waitFor();+ await page.getByText('Discovery complete!', { exact: true }).waitFor();+ group.checks.push(+ 'Late old-target HTTP and scanner completion cannot replace the current guest or finish its active HTTP request',+ );+ const posts = group.requests.filter((r) => r.method === 'POST');+ assert.equal(posts.length, 2);+ assert.deepEqual(+ posts.map((p) => JSON.parse(p.body)),+ [+ { force: true, hostname: 'guest-101' },+ { force: true, hostname: 'guest-102' },+ ],+ );+ await capture('current-guest-result');+ await emit({ resource_id: 'vm:fixture-node-agent:102', status: 'completed' });+ await page.waitForTimeout(650);+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);+ assert(await page.getByText('Current guest result', { exact: true }).isVisible());+ assert.equal(group.requests.filter((r) => r.method === 'POST').length, 2);+ group.checks.push(+ 'Later completion cannot strand the old HTTP success banner or issue an automatic scan',+ );+ fail = true;+ await pressRun();+ await alert.waitFor();+ assert((await alert.innerText()).includes('Guest execution paused: backup lock observed'));+ assert(await page.getByText('Current guest result', { exact: true }).isVisible());+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);+ await page.waitForTimeout(650);+ assert.equal(group.requests.filter((r) => r.method === 'POST').length, 3);+ group.checks.push(+ 'A failed explicit run retains prior saved evidence, visible failure and no automatic retry',+ );+ assert.deepEqual(group.errors, []);+ assert.deepEqual(group.offOrigin, []);+ await browser.close();+ browser = null;+ }+ report.result = 'passed';+ report.verified_at = new Date().toISOString();+ } catch (error) {+ report.result = 'failed';+ report.phase = phase;+ report.error = String(error.stack || error);+ throw error;+ } finally {+ if (browser) await browser.close();+ report.cleanup.browser_closed = true;+ await server.close();+ report.cleanup.server_closed = true;+ fs.writeFileSync(output + '/result.json', JSON.stringify(report, null, 2) + '\n');+ }+})().catch((error) => {+ console.error(error.stack || String(error));+ process.exitCode = 1;+});diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.html b/frontend-modern/browser-tests/discovery-outcome-ownership.htmlnew file mode 100644index 0000000000..7b3a737737--- /dev/null+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.html@@ -0,0 +1,12 @@+<!doctype html>+<html lang="en">+ <head>+ <meta charset="UTF-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />+ <title>Discovery outcome ownership evidence</title>+ </head>+ <body>+ <div id="root"></div>+ <script type="module" src="./discovery-outcome-ownership.tsx"></script>+ </body>+</html>diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.tsx b/frontend-modern/browser-tests/discovery-outcome-ownership.tsxnew file mode 100644index 0000000000..c9fe99348c--- /dev/null+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.tsx@@ -0,0 +1,54 @@+import { createSignal } from 'solid-js';+import { render } from 'solid-js/web';+import { Router, Route } from '@solidjs/router';+import { DiscoveryTab } from '../src/components/Discovery/DiscoveryTab';+import { eventBus } from '../src/stores/events';+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';+import type { DiscoveryProgress } from '../src/types/discovery';+import '../src/index.css';++declare global {+ interface Window {+ discoveryOwnership: {+ target: (id: string) => void;+ progress: (progress: DiscoveryProgress) => void;+ enabled: (enabled: boolean) => void;+ };+ }+}++function Fixture() {+ const [id, setId] = createSignal('101');+ const enabled = (discovery_enabled: boolean) =>+ syncAIRuntimeSettings({ discovery_enabled } as Parameters<typeof syncAIRuntimeSettings>[0]);+ enabled(true);+ window.discoveryOwnership = {+ target: setId,+ progress: (progress) => eventBus.emit('ai_discovery_progress', progress),+ enabled,+ };+ return (+ <main class="mx-auto min-h-screen max-w-4xl space-y-3 bg-surface p-3 text-base-content">+ <h1 class="text-base font-semibold">Discovery outcome ownership evidence</h1>+ <p class="text-xs text-muted">Synthetic guest responses. No guest command is sent.</p>+ <h2 class="text-sm font-medium">Guest {id()}</h2>+ <DiscoveryTab+ resourceType="vm"+ agentId="fixture-node-agent"+ resourceId={id()}+ canonicalResourceId={`fixture-pve1-${id()}`}+ hostname={`guest-${id()}`}+ showManualRunAction+ />+ </main>+ );+}++render(+ () => (+ <Router>+ <Route path="/*" component={Fixture} />+ </Router>+ ),+ document.getElementById('root')!,+);diff --git a/frontend-modern/browser-tests/guest-discovery-completion.cjs b/frontend-modern/browser-tests/guest-discovery-completion.cjsnew file mode 100644index 0000000000..25bb445ee3--- /dev/null+++ b/frontend-modern/browser-tests/guest-discovery-completion.cjs@@ -0,0 +1,19 @@+const { spawnSync } = require('node:child_process');+for (const script of ['guest-discovery-safety.cjs', 'discovery-outcome-ownership.cjs']) {+ const result = spawnSync(+ process.execPath,+ ['/workspace/frontend-modern/browser-tests/' + script],+ { stdio: 'inherit' },+ );+ if (result.status !== 0) {+ console.error(+ script,+ 'did not complete successfully',+ result.status,+ result.signal,+ result.error?.message,+ );+ process.exit(result.status || 1);+ }+}+console.log('Combined guest Discovery pause and outcome ownership browser proof passed.');diff --git a/frontend-modern/browser-verification/c45de66a92dcfc91.json b/frontend-modern/browser-verification/c45de66a92dcfc91.jsonnew file mode 100644index 0000000000..88b556048b--- /dev/null+++ b/frontend-modern/browser-verification/c45de66a92dcfc91.json@@ -0,0 +1,79 @@+{+ "version": 1,+ "base_sha": "bc3f4d81d14873caae6f769dfa670d16fa13d518",+ "verified_at": "2026-10-04T20:32:45.762Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/components/Discovery/DiscoveryTab.tsx",+ "frontend-modern/src/components/Discovery/useDiscoveryTabState.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/components/Discovery/DiscoveryTab.tsx": "2e93209a2b3830f77a0ad94d02bd59ea01509932f8d51e594d60f55d1f5895d0",+ "frontend-modern/src/components/Discovery/useDiscoveryTabState.ts": "e600bb993b80e85b6df48a9e070f1bc2db51d7bb8e5ffd6216e3861d610def14"+ },+ "routes": [+ "/browser-tests/guest-discovery-safety.html: production Workloads row, GuestDrawer and DiscoveryTab with synthetic canonical snapshots",+ "/browser-tests/discovery-outcome-ownership.html: reused production DiscoveryTab/state, synthetic per-guest APIs and production event-bus progress"+ ],+ "viewports": [+ {+ "width": 1365,+ "height": 900+ },+ {+ "width": 390,+ "height": 844+ },+ {+ "width": 320,+ "height": 844+ }+ ],+ "states": [+ "Guest operation lock and all current guest-read deferrals with/without retained data; healthy explicit action",+ "Original HTTP result retained after a same-target precaution without cancellation or another scan",+ "Background completed-with-error retains an accessible failed outcome and saved evidence",+ "Late old-target HTTP result cannot overwrite the current guest or stop its manual request",+ "Scanner completion during HTTP does not claim saved success; later terminal event cannot strand earlier success",+ "Current explicit failure remains visible without an automatic retry"+ ],+ "interactions": [+ "Keyboard and touch drawer expansion, Discovery tabs, explicit enabled runs and associated disabled reasons",+ "No POST on blocked/unlock/tab/snapshot change and exactly one target/body POST per explicit healthy action",+ "Keyboard-labelled error dismissal with saved content preserved",+ "Change target during an in-flight request, deliver the old and current responses independently and inspect original ownership",+ "Render desktop light/dark and WebKit 390px/320px, inspect wrapping and all 24 captures"+ ],+ "script": "frontend-modern/browser-tests/guest-discovery-completion.cjs",+ "browsers": [+ {+ "name": "desktop-light",+ "browser": "141.0.7390.37",+ "width": 1365,+ "dark": false+ },+ {+ "name": "desktop-dark",+ "browser": "141.0.7390.37",+ "width": 1365,+ "dark": true+ },+ {+ "name": "phone-dark",+ "browser": "26.0",+ "width": 390,+ "dark": true+ },+ {+ "name": "narrow-light",+ "browser": "26.0",+ "width": 320,+ "dark": false+ }+ ],+ "limitations": [+ "Synthetic inputs and API responses, not native QGA, backup or automatic poller acceptance.",+ "Vite-transformed production components. Exact production build is checked separately in the source-proof VM.",+ "No original freeze cause, independent thaw, covered-filesystem writes, installed use, physical phone or containing release is established."+ ]+}diff --git a/frontend-modern/src/components/Discovery/DiscoveryTab.tsx b/frontend-modern/src/components/Discovery/DiscoveryTab.tsxindex 169fd12981..a95395eed0 100644--- a/frontend-modern/src/components/Discovery/DiscoveryTab.tsx+++ b/frontend-modern/src/components/Discovery/DiscoveryTab.tsx@@ -474,7 +474,10 @@ export const DiscoveryTab: Component<DiscoveryTabProps> = (props) => {{/* Scan Error */}<Show when={scanError()}>- <div class="mb-4 rounded-md border border-red-200 bg-red-50 p-4 dark:border-red-800 dark:bg-red-900/25">+ <div+ role="alert"+ class="mb-4 rounded-md border border-red-200 bg-red-50 p-4 dark:border-red-800 dark:bg-red-900/25"+ ><div class="flex items-start gap-3"><svgclass="w-5 h-5 text-red-500 dark:text-red-400 shrink-0 mt-0.5"@@ -490,10 +493,14 @@ export const DiscoveryTab: Component<DiscoveryTabProps> = (props) => {/></svg><div>- <p class="text-sm font-medium text-red-800 dark:text-red-200">Discovery Failed</p>+ <p class="text-sm font-medium text-red-800 dark:text-red-200">+ Discovery did not complete+ </p><p class="text-sm text-red-700 dark:text-red-300 mt-1">{scanError()}</p></div><button+ type="button"+ aria-label="Dismiss Discovery error"onClick={() => setScanError(null)}class="ml-auto text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300">diff --git a/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsxindex ab6a4c1014..e2cdd43843 100644--- a/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx+++ b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx@@ -144,9 +144,13 @@ describe('Discovery outcome ownership', () => {vi.mocked(api.triggerDiscovery).mockReturnValueOnce(old.promise);const { state } = await mount();const first = state.handleTriggerDiscovery(true);- syncAIRuntimeSettings({ discovery_enabled: false } as Parameters<typeof syncAIRuntimeSettings>[0]);+ syncAIRuntimeSettings({ discovery_enabled: false } as Parameters<+ typeof syncAIRuntimeSettings+ >[0]);await waitFor(() => expect(state.canTriggerDiscovery()).toBe(false));- syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<typeof syncAIRuntimeSettings>[0]);+ syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<+ typeof syncAIRuntimeSettings+ >[0]);await waitFor(() => expect(state.canTriggerDiscovery()).toBe(true));old.resolve({ ...saved(), service_name: 'Disabled run result' });await first;@@ -188,6 +192,19 @@ describe('Discovery outcome ownership', () => {expect(state.scanSuccess()).toBe(false);});+ it('does not leave the previous HTTP success visible forever after a later completion event', async () => {+ const { state } = await mount();+ vi.useFakeTimers();+ await state.handleTriggerDiscovery(true);+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });+ await vi.advanceTimersByTimeAsync(2500);+ expect(state.scanSuccess()).toBe(false);+ expect(state.discovery()?.resource_id).toBe('100');+ });+it.each(['failed', 'completed'] as const)('retains a background %s-with-error outcome and the saved evidence, not silent success',async (status) => {@@ -219,10 +236,16 @@ describe('Discovery outcome ownership', () => {current_step: 'Collecting guest evidence',});expect(state.isScanning()).toBe(true);- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });expect(state.isScanning()).toBe(false);const first = state.handleTriggerDiscovery(true);- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });expect(state.isScanning()).toBe(true);expect(state.scanSuccess()).toBe(false);http.resolve(saved());@@ -233,7 +256,10 @@ describe('Discovery outcome ownership', () => {it('drops a delayed background refresh when its target changed before dispatch', async () => {const { state, setId } = await mount();vi.useFakeTimers();- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });setId('101');await Promise.resolve();const before = vi.mocked(api.getDiscovery).mock.calls.length;@@ -248,9 +274,15 @@ describe('Discovery outcome ownership', () => {const { state } = await mount();vi.mocked(api.getDiscovery).mockReturnValueOnce(refresh.promise);vi.useFakeTimers();- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });await vi.advanceTimersByTimeAsync(500);- vi.mocked(api.triggerDiscovery).mockResolvedValueOnce({ ...saved(), service_name: 'New manual result' });+ vi.mocked(api.triggerDiscovery).mockResolvedValueOnce({+ ...saved(),+ service_name: 'New manual result',+ });await state.handleTriggerDiscovery(true);refresh.resolve({ ...saved(), service_name: 'Old background result' });await Promise.resolve();@@ -258,6 +290,35 @@ describe('Discovery outcome ownership', () => {expect(state.scanSuccess()).toBe(true);});+ it.each([401, 403])(+ 'withdraws saved evidence when a completion refresh is denied with %s',+ async (status) => {+ const { state } = await mount();+ vi.mocked(api.getDiscovery).mockRejectedValueOnce(+ Object.assign(new Error('Discovery details unavailable.'), { status }),+ );+ vi.useFakeTimers();+ eventBus.emit('ai_discovery_progress', {+ resource_id: 'vm:node-agent:100',+ status: 'completed',+ });+ await vi.advanceTimersByTimeAsync(500);+ expect(state.discovery()).toBeNull();+ expect(state.scanSuccess()).toBe(false);+ expect(api.triggerDiscovery).not.toHaveBeenCalled();+ },+ );++ it('keeps saved evidence without success when HTTP supplies no result', async () => {+ vi.mocked(api.triggerDiscovery).mockResolvedValueOnce(null as unknown as ResourceDiscovery);+ const { state } = await mount();+ await state.handleTriggerDiscovery(true);+ expect(state.scanError()).toBe('Discovery returned no saved result.');+ expect(state.scanSuccess()).toBe(false);+ expect(state.discovery()?.service_name).toBe('Saved service 100');+ expect(state.isScanning()).toBe(false);+ });+it('does not close another guest’s notes editor when an old save finishes', async () => {const save = deferred<void>();vi.mocked(api.updateDiscoveryNotes).mockReturnValueOnce(save.promise);diff --git a/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts b/frontend-modern/src/components/Discovery/useDiscoveryTabState.tsindex b362dc984f..f45c6ae457 100644--- a/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts+++ b/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts@@ -47,6 +47,18 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {const [httpScanInProgress, setHttpScanInProgress] = createSignal(false);const [copiedDiscoveryValue, setCopiedDiscoveryValue] = createSignal('');let copyFeedbackTimer: ReturnType<typeof setTimeout> | undefined;+ let successTimer: ReturnType<typeof setTimeout> | undefined;+ let completionTimer: ReturnType<typeof setTimeout> | undefined;+ let contextVersion = 0;+ let runVersion = 0;+ let disposed = false;++ const clearScanTimers = () => {+ clearTimeout(successTimer);+ clearTimeout(completionTimer);+ successTimer = undefined;+ completionTimer = undefined;+ };const targetAgentId = createMemo(() => props.agentId || '');const discoverySourceKey = createMemo(@@ -59,6 +71,23 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {const { discoveryFeatureEnabled, discoveryFeatureKnownDisabled } =useDiscoveryFeatureAvailability();+ // A target key alone is insufficient: leaving and returning to the same+ // guest must not admit a response from the previous visit. A precaution on+ // the same target does not change this ownership or cancel dispatched work.+ const captureContext = () => ({+ version: contextVersion,+ key: discoverySourceKey(),+ type: props.resourceType,+ agentId: targetAgentId(),+ resourceId: props.resourceId,+ hostname: props.hostname,+ });+ const isCurrentContext = (context: ReturnType<typeof captureContext>) =>+ !disposed &&+ context.version === contextVersion &&+ context.key === discoverySourceKey() &&+ discoveryFeatureEnabled();+const [discoveryInfo] = createResource(() => (discoveryFeatureEnabled() ? props.resourceType : null),async (type) => {@@ -150,6 +179,9 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {createEffect(() => {void discoveryFeatureEnabled();void discoverySourceKey();+ contextVersion++;+ runVersion++;+ clearScanTimers();setIsScanning(false);setHttpScanInProgress(false);setScanProgress(null);@@ -193,14 +225,22 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {const handleTriggerDiscovery = async (force = false) => {// Check the current snapshot at the dispatch boundary as well as disabling- // buttons. A retained handler must not use an earlier enabled verdict.- // Do not cancel an already dispatched scan or hide its eventual outcome.- if (runBlockReason() || isScanning()) return;+ // buttons. Do not cancel a dispatched scan when a precaution appears.+ if (disposed || runBlockReason() || isScanning()) return;if (!discoveryFeatureEnabled()) {setScanError('Service context is disabled in Settings -> Pulse Intelligence -> Assistant.');return;}+ const context = captureContext();+ if (!context.agentId) {+ setScanError('Agent identifier unavailable for discovery');+ return;+ }+ if (!aiProviderConfigured()) return;+ clearScanTimers();+ const version = ++runVersion;+ const ownsRun = () => isCurrentContext(context) && version === runVersion;setIsScanning(true);setHttpScanInProgress(true);setScanProgress(null);@@ -210,59 +250,58 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {setLiveElapsedSeconds(0);try {- const agentId = targetAgentId();- if (!agentId) {- setScanError('Agent identifier unavailable for discovery');- return;- }-- const result = await triggerDiscovery(props.resourceType, agentId, props.resourceId, {+ const result = await triggerDiscovery(context.type, context.agentId, context.resourceId, {force,- hostname: props.hostname,+ hostname: context.hostname,});- if (result) {- mutate(result);- }-- setHttpScanInProgress(false);- setIsScanning(false);- setScanProgress(null);- setScanStartTime(null);+ if (!ownsRun()) return;+ if (!result) throw new Error('Discovery returned no saved result.');+ mutate(result);+ setScanError(null);setScanSuccess(true);- setTimeout(() => setScanSuccess(false), 2000);+ successTimer = setTimeout(() => {+ successTimer = undefined;+ if (ownsRun()) setScanSuccess(false);+ }, 2000);} catch (err) {+ if (!ownsRun()) return;console.error('Discovery failed:', err);const message = err instanceof Error ? err.message : 'Discovery scan failed';-- if (message.includes('no connected agent')) {- setScanError(getDiscoveryNoConnectedAgentMessage(props.commandsEnabled));- } else {- setScanError(message);+ setScanError(+ message.includes('no connected agent')+ ? getDiscoveryNoConnectedAgentMessage(props.commandsEnabled)+ : message,+ );+ } finally {+ if (ownsRun()) {+ setHttpScanInProgress(false);+ setIsScanning(false);+ setScanProgress(null);+ setScanStartTime(null);}-- setHttpScanInProgress(false);- setIsScanning(false);- setScanProgress(null);- setScanStartTime(null);}};const handleSaveNotes = async () => {+ if (disposed || !discoveryFeatureEnabled()) return;setSaveError(null);- const agentId = targetAgentId();- if (!agentId) {+ const context = captureContext();+ if (!context.agentId) {setSaveError('Agent identifier unavailable for discovery');return;}try {- await updateDiscoveryNotes(props.resourceType, agentId, props.resourceId, {+ await updateDiscoveryNotes(context.type, context.agentId, context.resourceId, {user_notes: notesText(),});+ if (!isCurrentContext(context)) return;setEditingNotes(false);await refetch();} catch (err) {- setSaveError(err instanceof Error ? err.message : 'Failed to save notes');+ if (isCurrentContext(context)) {+ setSaveError(err instanceof Error ? err.message : 'Failed to save notes');+ }}};@@ -278,14 +317,19 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {};onCleanup(() => {+ disposed = true;+ contextVersion++;+ runVersion++;+ clearScanTimers();clearCopyFeedbackTimer();});const handleCopyDiscoveryValue = async (value?: string | null) => {const text = (value || '').trim();if (!text) return;+ const context = captureContext();const copied = await copyToClipboard(text);- if (!copied) return;+ if (!copied || !isCurrentContext(context)) return;clearCopyFeedbackTimer();setCopiedDiscoveryValue(text);@@ -302,28 +346,56 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {if (!progress || progress.resource_id !== resourceId()) return;setScanProgress(progress);-- if (- (progress.status === 'completed' || progress.status === 'failed') &&- !httpScanInProgress()- ) {- setIsScanning(false);- setTimeout(async () => {- const agentId = targetAgentId();- if (!agentId) return;-- try {- const result = await getDiscovery(props.resourceType, agentId, props.resourceId);- if (result) {- mutate(result);- }- } catch (err) {- console.error('Failed to fetch discovery after completion:', err);- }-- setScanProgress(null);- }, 500);+ if (progress.status === 'running' || progress.status === 'pending') {+ if (!httpScanInProgress() && !isScanning()) {+ clearScanTimers();+ runVersion++;+ setScanError(null);+ setScanSuccess(false);+ const startedAt = Date.parse(progress.started_at || '');+ setScanStartTime(Number.isFinite(startedAt) ? startedAt : Date.now());+ }+ setIsScanning(true);+ return;}+ if (progress.status !== 'completed' && progress.status !== 'failed') return;++ // The scanner can emit completed-with-error when QGA is paused or no+ // command evidence was collected. It is not successful saved Discovery.+ // Keep that reason visible even when this tab did not initiate the scan.+ const error =+ progress.error?.trim() || (progress.status === 'failed' ? 'Discovery scan failed.' : null);+ if (error) {+ setScanError(error);+ setScanSuccess(false);+ }+ // Scanner completion can precede analysis/persistence. A manual request+ // owns its final result until HTTP settles, not an intermediate event.+ if (httpScanInProgress()) return;++ clearScanTimers();+ const version = ++runVersion;+ setScanSuccess(false);+ setIsScanning(false);+ setScanStartTime(null);+ setScanProgress(null);+ if (error) return;++ const context = captureContext();+ const ownsRefresh = () => isCurrentContext(context) && version === runVersion;+ completionTimer = setTimeout(async () => {+ completionTimer = undefined;+ if (!context.agentId || !ownsRefresh()) return;+ try {+ const result = await getDiscovery(context.type, context.agentId, context.resourceId);+ if (ownsRefresh()) mutate(result);+ } catch (err) {+ if (!ownsRefresh()) return;+ const status = (err as { status?: number } | null)?.status;+ if (status === 401 || status === 403) mutate(null);+ console.error('Failed to fetch discovery after completion:', err);+ }+ }, 500);});onCleanup(() => {