fix: give imported workflows their own run-error bucket

loadApiJson() and importA1111() populate the root graph in place and never
call configure(), so it keeps the zero id that LGraph.clear() leaves behind.
Every such import shared one bucket, and the first reload swapped the zero id
for a generated one, losing the parked errors again.

afterLoadNewGraph() now mints an id for a zero-id root graph before selecting
the bucket, and writes it back into the state this load persists so the
reload lands on the same key.

Addresses #15361 (comment)

Author: christian-byrne

src/platform/workflow/core/services/workflowService.ts

@@ -37,12 +37,31 @@ import {
   generateUUID
 } from '@/utils/formatUtil'
 import type { AppMode } from '@/utils/appMode'
+import type { UUID } from '@/utils/uuid'
+import { createUuidv4, zeroUuid } from '@/utils/uuid'
 
 function linearModeToAppMode(linearMode: unknown): AppMode | null {
   if (typeof linearMode !== 'boolean') return null
   return linearMode ? 'app' : 'graph'
 }
 
+/**
+ * Returns the root graph id to scope run errors by, minting one when the graph
+ * carries the zero id. `loadApiJson` and `importA1111` populate the root graph
+ * without `configure()`, so every such import would otherwise share the zero
+ * id's bucket and lose it once a reload generated a real id. The id is written
+ * back into `workflowData` so the state this load persists reloads under the
+ * same key.
+ */
+function adoptRootGraphId(workflowData: ComfyWorkflowJSON): UUID | null {
+  if (!app.isGraphReady) return null
+
+  const rootGraph = app.rootGraph
+  if (rootGraph.id === zeroUuid) rootGraph.id = createUuidv4()
+  workflowData.id = rootGraph.id
+  return rootGraph.id
+}
+
 export const useWorkflowService = () => {
   const settingStore = useSettingStore()
   const workflowStore = useWorkflowStore()
@@ -452,9 +471,7 @@ export const useWorkflowService = () => {
     const { isAppMode } = useAppMode()
     const wasAppMode = isAppMode.value
 
-    useExecutionErrorStore().setActiveGraph(
-      app.isGraphReady ? app.rootGraph.id : null
-    )
+    useExecutionErrorStore().setActiveGraph(adoptRootGraphId(workflowData))
 
     // Determine the initial app mode for fresh loads from serialized state.
     // null means linearMode was never explicitly set (not builder-saved).

src/scripts/app.test.ts

@@ -50,6 +50,7 @@ import {
 } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers'
 import { useWidgetValueStore } from '@/stores/widgetValueStore'
 import { extractFilesFromDragEvent } from '@/utils/eventUtils'
+import { zeroUuid } from '@/utils/uuid'
 import type { importA1111 } from './pnginfo'
 
 type WorkflowService = ReturnType<typeof useWorkflowService>
@@ -1182,6 +1183,20 @@ describe('ComfyApp', () => {
       )
     }
 
+    /** Mirrors `loadApiJson`/`importA1111`: the root graph is populated in
+     *  place and never configured, so it still carries the zero id. */
+    async function importWorkflow(
+      workflowService: WorkflowService,
+      graph: LGraph,
+      workflow: ComfyWorkflow
+    ): Promise<ComfyWorkflowJSON> {
+      workflowService.beforeLoadNewGraph()
+      app.clean()
+      const workflowData = { ...createWorkflowGraphData(), id: graph.id }
+      await workflowService.afterLoadNewGraph(workflow, workflowData)
+      return workflowData
+    }
+
     it('restores the failed run state when returning to a workflow tab', async () => {
       const workflowService = await useRealWorkflowService()
       const graph = new LGraph()
@@ -1210,6 +1225,52 @@ describe('ComfyApp', () => {
       expect(executionErrorStore.lastNodeErrors).toEqual(failedKSamplerErrors)
       expect(executionErrorStore.totalErrorCount).toBe(1)
     })
+
+    it('gives each imported workflow its own restorable run errors', async () => {
+      const workflowService = await useRealWorkflowService()
+      const graph = new LGraph()
+      Reflect.set(app, 'rootGraphInternal', graph)
+      Reflect.set(singletonApp, 'rootGraphInternal', graph)
+
+      const importedA = markLoaded(
+        new ComfyWorkflow({
+          path: 'workflows/api-a.json',
+          modified: 0,
+          size: 0
+        })
+      )
+      const importedB = markLoaded(
+        new ComfyWorkflow({
+          path: 'workflows/api-b.json',
+          modified: 0,
+          size: 0
+        })
+      )
+
+      const firstImport = await importWorkflow(
+        workflowService,
+        graph,
+        importedA
+      )
+      expect(firstImport.id).not.toBe(zeroUuid)
+      expect(firstImport.id).toBe(graph.id)
+
+      const executionErrorStore = useExecutionErrorStore()
+      executionErrorStore.recordNodeErrors(failedKSamplerErrors)
+
+      const secondImport = await importWorkflow(
+        workflowService,
+        graph,
+        importedB
+      )
+      expect(secondImport.id).not.toBe(firstImport.id)
+      expect(executionErrorStore.lastNodeErrors).toBeNull()
+
+      // Reopening the first import replays the state it persisted.
+      await switchToWorkflow(workflowService, graph, importedA, firstImport.id!)
+
+      expect(executionErrorStore.lastNodeErrors).toEqual(failedKSamplerErrors)
+    })
   })
 
   describe('refreshComboInNodes', () => {