fix: re-check tab fallback after deferred error scans (#15012)

## Summary

Pasted and duplicated nodes register widgets before their deferred
missing-model and missing-media scans finish. The right-side panel could
therefore recalculate its tabs, see no selected-node error yet, and
switch away from Errors permanently.

This change tracks graph-scoped added-node scans from node addition
through asynchronous verification. An already-active Errors tab remains
available while its selected node is being scanned, then either stays
active when an error surfaces or falls back when the scan settles
cleanly.

Scan lifecycle handling now:

- reference-counts overlapping scans by root graph and execution ID
- releases the tab hold without aborting valid verification during
subgraph navigation
- aborts verification when the scanned node is removed
- suppresses late results after workflow/node replacement, widget
changes, or ownership changes
- waits for already-started verification when a later scan stage fails

## Testing

- Added focused component coverage for pending, error, clean fallback,
unmount, and subgraph-interior selection behavior.
- Added lifecycle coverage for overlapping scans, graph isolation,
disposal, workflow replacement, model/media cancellation, changed
values, and scan-stage failures.
- Added a Playwright flow covering paste, delayed cloud verification,
retained Errors selection, surfaced errors, and clean fallback after
resolution.
- `pnpm test:unit src/components/rightSidePanel/RightSidePanel.test.ts
src/composables/graph/useErrorClearingHooks.test.ts
src/stores/executionErrorStore.test.ts`
- `pnpm typecheck`
- ESLint and Oxfmt on changed files

---------

Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: GitHub Action <action@github.com>

Author: 3 people

browser_tests/tests/propertiesPanel/errorsTabCloudMissingModels.spec.ts

@@ -39,6 +39,18 @@ const CLOUD_UNKNOWN_MODEL_NAME = 'cloud_unknown_model.safetensors'
 const CLOUD_IMPORTED_CANONICAL_MODEL_NAME =
   'models/checkpoints/cloud_importable_model.safetensors'
 
+const FAKE_MODEL_ASSET: Asset = {
+  id: 'test-fake-checkpoint',
+  name: FAKE_MODEL_NAME,
+  size: 1_024,
+  mime_type: 'application/octet-stream',
+  tags: ['models', 'checkpoints'],
+  created_at: '2026-05-05T00:00:00Z',
+  updated_at: '2026-05-05T00:00:00Z',
+  last_access_time: '2026-05-05T00:00:00Z',
+  user_metadata: { filename: FAKE_MODEL_NAME }
+}
+
 const LOTUS_DIFFUSION_MODEL: Asset & { hash?: string } = {
   id: 'test-lotus-depth-d-v1-1',
   name: LOTUS_MODEL_NAME,
@@ -183,6 +195,64 @@ test.describe(
       await expect(errorsTab).toBeHidden()
     })
 
+    test('keeps Errors active through pasted-node verification and falls back when resolved', async ({
+      comfyPage
+    }) => {
+      await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_models')
+      const panel = new PropertiesPanelHelper(comfyPage.page)
+      const missingModelsGroup = comfyPage.page.getByTestId(
+        TestIds.dialogs.missingModelsGroup
+      )
+      let visibleAssets: Asset[] = []
+      let markVerificationStarted: () => void = () => undefined
+      const verificationStarted = new Promise<void>((resolve) => {
+        markVerificationStarted = resolve
+      })
+      let releaseVerification: () => void = () => undefined
+      const verificationGate = new Promise<void>((resolve) => {
+        releaseVerification = resolve
+      })
+      await comfyPage.page.route(/\/api\/assets(?:\?.*)?$/, async (route) => {
+        markVerificationStarted()
+        await verificationGate
+        const response: ListAssetsResponse = {
+          assets: visibleAssets,
+          total: visibleAssets.length,
+          has_more: false
+        }
+        await route.fulfill({ json: response })
+      })
+
+      const source = await comfyPage.nodeOps.getNodeRefById('1')
+      await source.click('title')
+      await comfyPage.clipboard.copy()
+      await comfyPage.clipboard.paste()
+      await verificationStarted
+
+      await expect(panel.errorsTab).toHaveAttribute('aria-selected', 'true')
+      releaseVerification()
+      await expect.poll(() => comfyPage.nodeOps.getNodeCount()).toBe(2)
+      await expect(
+        missingModelsGroup.getByTestId(
+          TestIds.dialogs.missingModelReferenceCount
+        )
+      ).toHaveText('2')
+      await expect(panel.errorsTab).toHaveAttribute('aria-selected', 'true')
+
+      visibleAssets = [FAKE_MODEL_ASSET]
+      await source.click('title')
+      await comfyPage.clipboard.copy()
+      await comfyPage.clipboard.paste()
+
+      await expect.poll(() => comfyPage.nodeOps.getNodeCount()).toBe(3)
+      await expect(missingModelsGroup).toBeHidden()
+      await expect(panel.errorsTab).toBeHidden()
+      await expect(panel.getTab('Parameters')).toHaveAttribute(
+        'aria-selected',
+        'true'
+      )
+    })
+
     test('separates importable cloud models from unsupported rows', async ({
       comfyPage
     }) => {

src/components/rightSidePanel/RightSidePanel.test.ts

@@ -0,0 +1,196 @@
+import { createTestingPinia } from '@pinia/testing'
+import { render, screen } from '@testing-library/vue'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { markRaw, nextTick } from 'vue'
+import { createI18n } from 'vue-i18n'
+
+import RightSidePanel from '@/components/rightSidePanel/RightSidePanel.vue'
+import { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
+import {
+  createTestSubgraph,
+  createTestSubgraphNode
+} from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers'
+import enMessages from '@/locales/en/main.json' with { type: 'json' }
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { useExecutionErrorStore } from '@/stores/executionErrorStore'
+import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
+import { getExecutionIdByNode } from '@/utils/graphTraversalUtil'
+import { toNodeId } from '@/types/nodeId'
+
+const mockApp = vi.hoisted(() => ({
+  isGraphReady: true,
+  rootGraph: null as LGraph | null
+}))
+
+vi.mock('@/scripts/app', () => ({ app: mockApp }))
+
+vi.mock('@/composables/graph/useGraphHierarchy', () => ({
+  useGraphHierarchy: () => ({ findParentGroup: vi.fn(() => null) })
+}))
+
+vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
+
+vi.mock('@/platform/settings/settingStore', () => ({
+  useSettingStore: () => ({
+    get: (key: string) => {
+      if (key === 'Comfy.RightSidePanel.ShowErrorsTab') return true
+      if (key === 'Comfy.Sidebar.Location') return 'left'
+      if (key === 'Comfy.UseNewMenu') return 'Top'
+      if (key === 'Comfy.RightSidePanel.IsOpen') return true
+      return undefined
+    },
+    set: vi.fn()
+  })
+}))
+
+function renderPanel(
+  activeTab: 'errors' | 'parameters' = 'errors',
+  graphContext?: {
+    rootGraph: LGraph
+    currentGraph: LGraph
+    node: LGraphNode
+  }
+) {
+  const pinia = createTestingPinia({ createSpy: vi.fn, stubActions: false })
+  setActivePinia(pinia)
+
+  const rootGraph = graphContext?.rootGraph ?? new LGraph()
+  const currentGraph = graphContext?.currentGraph ?? rootGraph
+  const node = graphContext?.node ?? new LGraphNode('CheckpointLoaderSimple')
+  if (!graphContext) {
+    node.id = toNodeId(1)
+    rootGraph.add(node)
+  }
+  mockApp.rootGraph = rootGraph
+
+  const canvasStore = useCanvasStore()
+  canvasStore.currentGraph = currentGraph
+  canvasStore.selectedItems = [markRaw(node)]
+
+  const rightSidePanelStore = useRightSidePanelStore()
+  rightSidePanelStore.activeTab = activeTab
+  const executionErrorStore = useExecutionErrorStore()
+  const executionId = getExecutionIdByNode(rootGraph, node)
+  if (!executionId) throw new Error('Expected selected node execution ID')
+  const finishScan = executionErrorStore.beginAddedNodeErrorScan(
+    rootGraph,
+    executionId
+  )
+  const openPanel = vi.spyOn(rightSidePanelStore, 'openPanel')
+
+  const i18n = createI18n({
+    legacy: false,
+    locale: 'en',
+    messages: { en: enMessages }
+  })
+
+  const rendered = render(RightSidePanel, {
+    global: {
+      plugins: [pinia, i18n],
+      stubs: {
+        Button: { template: '<button><slot /></button>' },
+        EditableText: true,
+        Tab: { template: '<button v-bind="$attrs"><slot /></button>' },
+        TabErrors: true,
+        TabInfo: true,
+        TabList: { template: '<div><slot /></div>' },
+        TabNormalInputs: true,
+        TabSettings: true
+      }
+    }
+  })
+
+  return {
+    ...rendered,
+    executionId,
+    executionErrorStore,
+    finishScan,
+    graph: rootGraph,
+    node,
+    openPanel,
+    rightSidePanelStore
+  }
+}
+
+describe('RightSidePanel active tab fallback', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+    mockApp.rootGraph = null
+  })
+
+  it('keeps the active errors tab until the selected node scan settles', async () => {
+    const { finishScan, openPanel, rightSidePanelStore } = renderPanel()
+
+    expect(screen.getByTestId('panel-tab-errors')).toBeInTheDocument()
+    expect(rightSidePanelStore.activeTab).toBe('errors')
+    expect(openPanel).not.toHaveBeenCalled()
+
+    vi.spyOn(globalThis, 'queueMicrotask').mockImplementation(() => undefined)
+    finishScan()
+    await nextTick()
+
+    expect(rightSidePanelStore.activeTab).toBe('parameters')
+    expect(openPanel).toHaveBeenCalledWith('parameters')
+  })
+
+  it('keeps errors active when the scan surfaces an error before settling', async () => {
+    const { executionId, finishScan, openPanel, rightSidePanelStore } =
+      renderPanel()
+
+    useMissingModelStore().addMissingModels([
+      {
+        nodeId: executionId,
+        nodeType: 'CheckpointLoaderSimple',
+        widgetName: 'ckpt_name',
+        isAssetSupported: false,
+        name: 'missing.safetensors',
+        directory: 'checkpoints',
+        isMissing: true
+      }
+    ])
+    finishScan()
+    await nextTick()
+
+    expect(rightSidePanelStore.activeTab).toBe('errors')
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+
+  it('does not show errors solely because a scan is pending', () => {
+    const { openPanel } = renderPanel('parameters')
+
+    expect(screen.queryByTestId('panel-tab-errors')).not.toBeInTheDocument()
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+
+  it('does not update the panel when a pending scan finishes after unmount', async () => {
+    const { finishScan, openPanel, unmount } = renderPanel()
+    unmount()
+    finishScan()
+    await nextTick()
+
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+
+  it('keeps errors active for a pending subgraph interior node scan', () => {
+    setActivePinia(createTestingPinia({ createSpy: vi.fn, stubActions: false }))
+    const subgraph = createTestSubgraph()
+    const node = new LGraphNode('CheckpointLoaderSimple')
+    node.id = toNodeId(7)
+    subgraph.add(node)
+    const host = createTestSubgraphNode(subgraph, { id: 65 })
+    const rootGraph = host.graph as LGraph
+    rootGraph.add(host)
+
+    const { executionErrorStore, executionId, openPanel, rightSidePanelStore } =
+      renderPanel('errors', { rootGraph, currentGraph: subgraph, node })
+
+    expect(
+      executionErrorStore.hasPendingAddedNodeErrorScan(rootGraph, executionId)
+    ).toBe(true)
+    expect(screen.getByTestId('panel-tab-errors')).toBeInTheDocument()
+    expect(rightSidePanelStore.activeTab).toBe('errors')
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+})

src/components/rightSidePanel/RightSidePanel.vue

@@ -9,7 +9,10 @@ import TabList from '@/components/tab/TabList.vue'
 import Button from '@/components/ui/button/Button.vue'
 import { useGraphHierarchy } from '@/composables/graph/useGraphHierarchy'
 import { app } from '@/scripts/app'
-import { getActiveGraphNodeIds } from '@/utils/graphTraversalUtil'
+import {
+  getActiveGraphNodeIds,
+  getExecutionIdByNode
+} from '@/utils/graphTraversalUtil'
 import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { useSettingStore } from '@/platform/settings/settingStore'
@@ -173,12 +176,26 @@ const hasRelevantErrors = computed(() => {
   )
 })
 
+const hasPendingErrorScanSelected = computed(() => {
+  const nodes = selectedNodes.value
+  if (!app.isGraphReady) return false
+  const rootGraph = app.rootGraph
+  return nodes.some((node) => {
+    const executionId = getExecutionIdByNode(rootGraph, node)
+    return (
+      executionId !== null &&
+      executionErrorStore.hasPendingAddedNodeErrorScan(rootGraph, executionId)
+    )
+  })
+})
+
 const tabs = computed<RightSidePanelTabList>(() => {
   const list: RightSidePanelTabList = []
 
   if (
     settingStore.get('Comfy.RightSidePanel.ShowErrorsTab') &&
-    hasRelevantErrors.value
+    (hasRelevantErrors.value ||
+      (activeTab.value === 'errors' && hasPendingErrorScanSelected.value))
   ) {
     list.push({
       label: () => t('rightSidePanel.errors'),
@@ -222,12 +239,15 @@ const tabs = computed<RightSidePanelTabList>(() => {
   return list
 })
 
-// Use global state for activeTab and ensure it's valid
+function isActiveTabAvailable() {
+  return (
+    tabs.value.some((tab) => tab.value === activeTab.value) ||
+    (activeTab.value === 'subgraph' && isSingleSubgraphNode.value)
+  )
+}
+
 watchEffect(() => {
-  if (
-    !tabs.value.some((tab) => tab.value === activeTab.value) &&
-    !(activeTab.value === 'subgraph' && isSingleSubgraphNode.value)
-  ) {
+  if (!isActiveTabAvailable()) {
     rightSidePanelStore.openPanel(tabs.value[0].value)
   }
 })