fix(workflows): correct reference resolution for active mode, cycles, cache, and graph size

Addresses review findings on the reference viewer:

- Resolve the workflow-block child via resolveActiveCanonicalValue (the
  shared SOT) instead of basic-first `||`, so an advanced-mode block whose
  old basic workflowId value lingers resolves to the active manual value.
- Keep self-references (A -> A) and render them as a cycle leaf instead of
  dropping the edge, matching the cycle-safe viewer's purpose.
- Set the references query staleTime to 0 so reopening the always-mounted
  modal refetches live editor state instead of serving a stale cached graph.
- Bound converging paths: a node already expanded elsewhere in the tree is
  emitted once more as a plain leaf (edge stays visible) rather than
  re-expanded, so a densely reconverging graph can't grow exponentially.

Author: mzxchandra

apps/sim/hooks/queries/workflow-references.ts

@@ -5,8 +5,13 @@ import {
   type WorkflowReferencesResponse,
 } from '@/lib/api/contracts/workflow-references'
 
-/** Short — the graph reflects live editor state and should stay fresh on reopen. */
-export const WORKFLOW_REFERENCES_STALE_TIME = 30 * 1000
+/**
+ * Zero — the graph reflects live editor state (workflow blocks/names can change
+ * between opens). The modal stays mounted with the query disabled while closed, so
+ * a non-zero window would serve a cached graph on reopen without refetching. Zero
+ * marks the data stale immediately, forcing a refetch each time the modal reopens.
+ */
+export const WORKFLOW_REFERENCES_STALE_TIME = 0
 
 export const workflowReferenceKeys = {
   all: ['workflow-references'] as const,

apps/sim/lib/workflows/references/operations.test.ts

@@ -27,6 +27,7 @@ function workflowBlock(
     type,
     childFromSelector: mode === 'basic' ? childId : null,
     childFromManual: mode === 'manual' ? childId : null,
+    canonicalModes: null,
   }
 }
 
@@ -65,6 +66,22 @@ describe('resolveWorkflowReferences', () => {
     expect(callees.map((n) => n.id)).toEqual(['b'])
   })
 
+  it('uses the active mode, not a retained inactive value', () => {
+    // Advanced mode active (canonicalModes override), but a stale basic value
+    // (`b`) lingers. Must resolve to the advanced value (`c`), not the stale basic.
+    const blocks: ReferenceBlockRow[] = [
+      {
+        parentId: 'a',
+        type: 'workflow',
+        childFromSelector: 'b',
+        childFromManual: 'c',
+        canonicalModes: { workflowId: 'advanced' },
+      },
+    ]
+    const { callees } = resolveWorkflowReferences('a', workflows, blocks, [])
+    expect(callees.map((n) => n.id)).toEqual(['c'])
+  })
+
   it('marks cycles as leaves and stops recursing', () => {
     // A → B → A
     const blocks = [workflowBlock('a', 'b'), workflowBlock('b', 'a')]
@@ -76,11 +93,30 @@ describe('resolveWorkflowReferences', () => {
     expect(callees[0].children[0]).toMatchObject({ id: 'a', cycle: true, children: [] })
   })
 
-  it('drops self-references', () => {
+  it('shows a self-reference as a cycle leaf', () => {
+    // A → A: the reference is real and belongs in the cycle-safe viewer.
     const blocks = [workflowBlock('a', 'a')]
     const { callers, callees } = resolveWorkflowReferences('a', workflows, blocks, [])
-    expect(callers).toEqual([])
-    expect(callees).toEqual([])
+    expect(callees).toEqual([{ id: 'a', name: 'A', cycle: true, children: [] }])
+    expect(callers).toEqual([{ id: 'a', name: 'A', cycle: true, children: [] }])
+  })
+
+  it('bounds converging paths (diamond) instead of re-expanding', () => {
+    // A → B, A → C, B → D, C → D. D reconverges; it must appear under both B and C
+    // but only expand once (here D is a leaf anyway; the guard prevents blow-up).
+    const blocks = [
+      workflowBlock('a', 'b'),
+      workflowBlock('a', 'c'),
+      workflowBlock('b', 'd'),
+      workflowBlock('c', 'd'),
+    ]
+    const { callees } = resolveWorkflowReferences('a', workflows, blocks, [])
+    const b = callees.find((n) => n.id === 'b')
+    const c = callees.find((n) => n.id === 'c')
+    // D expands under the first-visited branch (B) and is a plain leaf under C.
+    expect(b?.children.map((n) => n.id)).toEqual(['d'])
+    expect(c?.children.map((n) => n.id)).toEqual(['d'])
+    expect(c?.children[0]).toMatchObject({ id: 'd', cycle: false, children: [] })
   })
 
   it('drops dangling / out-of-workspace child ids', () => {
@@ -92,7 +128,13 @@ describe('resolveWorkflowReferences', () => {
   it('resolves references made through custom blocks', () => {
     // D places custom_block_x, which is bound to source workflow C.
     const blocks: ReferenceBlockRow[] = [
-      { parentId: 'd', type: 'custom_block_x', childFromSelector: null, childFromManual: null },
+      {
+        parentId: 'd',
+        type: 'custom_block_x',
+        childFromSelector: null,
+        childFromManual: null,
+        canonicalModes: null,
+      },
     ]
     const customBlocks: CustomBlockLink[] = [{ type: 'custom_block_x', workflowId: 'c' }]
 
@@ -110,6 +152,7 @@ describe('resolveWorkflowReferences', () => {
         type: 'custom_block_unknown',
         childFromSelector: null,
         childFromManual: null,
+        canonicalModes: null,
       },
     ]
     const { callees } = resolveWorkflowReferences('d', workflows, blocks, [])

apps/sim/lib/workflows/references/operations.ts

@@ -4,6 +4,11 @@ import { createLogger } from '@sim/logger'
 import { and, eq, inArray, isNull, like, or, sql } from 'drizzle-orm'
 import type { ReferenceNode } from '@/lib/api/contracts/workflow-references'
 import { getCustomBlockRowsForWorkspace } from '@/lib/workflows/custom-blocks/operations'
+import {
+  type CanonicalGroup,
+  type CanonicalModeOverrides,
+  resolveActiveCanonicalValue,
+} from '@/lib/workflows/subblocks/visibility'
 import { CUSTOM_BLOCK_TYPE_PREFIX } from '@/blocks/custom/build-config'
 import { BlockType, isWorkflowBlockType } from '@/executor/constants'
 
@@ -16,6 +21,18 @@ const logger = createLogger('WorkflowReferences')
  */
 const MAX_REFERENCE_DEPTH = 25
 
+/**
+ * The `workflowId` canonical pair on a workflow / workflow_input block: the basic
+ * `workflowId` selector and the advanced `manualWorkflowId` input. Used with
+ * {@link resolveActiveCanonicalValue} so the reference resolves to the value of the
+ * block's ACTIVE mode — never a dormant mode's retained (stale) value.
+ */
+const WORKFLOW_ID_CANONICAL_GROUP: CanonicalGroup = {
+  canonicalId: 'workflowId',
+  basicId: 'workflowId',
+  advancedIds: ['manualWorkflowId'],
+}
+
 /** A workspace-local, non-archived workflow node. */
 export interface WorkflowNode {
   id: string
@@ -30,6 +47,11 @@ export interface ReferenceBlockRow {
   childFromSelector: string | null
   /** `manualWorkflowId` sub-block value (advanced mode), if a workflow block. */
   childFromManual: string | null
+  /**
+   * The block's `data.canonicalModes` override (basic/advanced per canonical id),
+   * used to pick the active `workflowId` value. Absent for most blocks.
+   */
+  canonicalModes: CanonicalModeOverrides | null
 }
 
 /** A custom-block type slug bound to its source workflow. */
@@ -56,8 +78,11 @@ interface ReferenceGraph {
  * - **custom blocks** (`custom_block_<id>`), whose type slug maps to a bound
  *   source workflow via `customBlocks`.
  *
- * Edges are scoped to workspace-local, non-archived workflows: self-references,
- * empty values, and ids outside `workflows` are dropped.
+ * The workflow-block child is the value of the block's ACTIVE mode
+ * ({@link resolveActiveCanonicalValue}), so a dormant basic/advanced value can't
+ * mask the live one. Edges are scoped to workspace-local, non-archived workflows;
+ * empty values and ids outside `workflows` are dropped. A workflow that calls
+ * itself is kept — the tree builder renders it as a `cycle` leaf.
  */
 export function buildReferenceGraph(
   workflows: WorkflowNode[],
@@ -74,7 +99,7 @@ export function buildReferenceGraph(
   const reverse = new Map<string, Set<string>>()
 
   const addEdge = (parentId: string, childId: string) => {
-    if (!childId || childId === parentId) return
+    if (!childId) return
     if (!nameById.has(parentId) || !nameById.has(childId)) return
     if (!forward.has(parentId)) forward.set(parentId, new Set())
     forward.get(parentId)?.add(childId)
@@ -84,8 +109,12 @@ export function buildReferenceGraph(
 
   for (const block of blocks) {
     if (isWorkflowBlockType(block.type)) {
-      const childId = block.childFromSelector || block.childFromManual
-      if (childId) addEdge(block.parentId, childId)
+      const active = resolveActiveCanonicalValue(
+        WORKFLOW_ID_CANONICAL_GROUP,
+        { workflowId: block.childFromSelector, manualWorkflowId: block.childFromManual },
+        block.canonicalModes ?? undefined
+      )
+      if (typeof active === 'string' && active) addEdge(block.parentId, active)
       continue
     }
     const sourceId = sourceByCustomType.get(block.type)
@@ -97,16 +126,22 @@ export function buildReferenceGraph(
 
 /**
  * Expand a direction of the graph into a tree rooted at `rootId`. `adjacency` is
- * either the forward (callees) or reverse (callers) map. A node already on the
- * current DFS path is emitted as a `cycle: true` leaf and not re-expanded, so
- * `A → B → A` terminates. Children are sorted by name for stable rendering.
+ * either the forward (callees) or reverse (callers) map.
+ *
+ * A node already on the current DFS path is emitted as a `cycle: true` leaf and
+ * not re-expanded, so `A → B → A` (and a self-call `A → A`) terminates. A node
+ * already fully expanded elsewhere in this tree (reachable via another acyclic
+ * path — a diamond) is emitted once more as a plain leaf without re-expanding its
+ * subtree: the edge stays visible, but a densely reconverging graph can't blow up
+ * exponentially. Children are sorted by name for stable rendering.
  */
 function buildTree(
   rootId: string,
   adjacency: Map<string, Set<string>>,
   nameById: Map<string, string>
 ): ReferenceNode[] {
   const path = new Set<string>([rootId])
+  const expanded = new Set<string>()
 
   const expand = (id: string, depth: number): ReferenceNode[] => {
     if (depth >= MAX_REFERENCE_DEPTH) return []
@@ -126,6 +161,11 @@ function buildTree(
         nodes.push({ id: childId, name, cycle: true, children: [] })
         continue
       }
+      if (expanded.has(childId)) {
+        nodes.push({ id: childId, name, cycle: false, children: [] })
+        continue
+      }
+      expanded.add(childId)
       path.add(childId)
       nodes.push({ id: childId, name, cycle: false, children: expand(childId, depth + 1) })
       path.delete(childId)
@@ -185,6 +225,7 @@ export async function getWorkflowReferences(
         childFromManual: sql<
           string | null
         >`${workflowBlocks.subBlocks} -> 'manualWorkflowId' ->> 'value'`,
+        canonicalModes: sql<CanonicalModeOverrides | null>`${workflowBlocks.data} -> 'canonicalModes'`,
       })
       .from(workflowBlocks)
       .innerJoin(workflow, eq(workflow.id, workflowBlocks.workflowId))