@swarmclawai/swarmclaw 1.3.6 → 1.4.2

package/src/features/protocols/builder/utils/template-to-nodes.test.ts

@@ -0,0 +1,314 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getNodeTypeForKind, templateToNodes } from './template-to-nodes'
+import type { ProtocolTemplate, ProtocolStepDefinition, ProtocolPhaseDefinition } from '@/types'
+
+// --- getNodeTypeForKind ---
+
+describe('getNodeTypeForKind', () => {
+  it('maps all ProtocolPhaseKind values to "phase"', () => {
+    const phaseKinds = [
+      'present',
+      'collect_independent_inputs',
+      'round_robin',
+      'compare',
+      'decide',
+      'summarize',
+      'emit_tasks',
+      'wait',
+      'dispatch_task',
+      'dispatch_delegation',
+    ] as const
+
+    for (const kind of phaseKinds) {
+      assert.strictEqual(getNodeTypeForKind(kind), 'phase')
+    }
+  })
+
+  it('maps branch to "branch"', () => {
+    assert.strictEqual(getNodeTypeForKind('branch'), 'branch')
+  })
+
+  it('maps repeat to "loop"', () => {
+    assert.strictEqual(getNodeTypeForKind('repeat'), 'loop')
+  })
+
+  it('maps parallel to "parallel"', () => {
+    assert.strictEqual(getNodeTypeForKind('parallel'), 'parallel')
+  })
+
+  it('maps join to "join"', () => {
+    assert.strictEqual(getNodeTypeForKind('join'), 'join')
+  })
+
+  it('maps complete to "complete"', () => {
+    assert.strictEqual(getNodeTypeForKind('complete'), 'complete')
+  })
+
+  it('maps for_each to "forEach"', () => {
+    assert.strictEqual(getNodeTypeForKind('for_each'), 'forEach')
+  })
+
+  it('maps subflow to "subflow"', () => {
+    assert.strictEqual(getNodeTypeForKind('subflow'), 'subflow')
+  })
+
+  it('maps swarm_claim to "swarm"', () => {
+    assert.strictEqual(getNodeTypeForKind('swarm_claim'), 'swarm')
+  })
+})
+
+// --- templateToNodes ---
+
+function makeTemplate(overrides: Partial<ProtocolTemplate> = {}): ProtocolTemplate {
+  return {
+    id: 'tpl-1',
+    name: 'Test Template',
+    description: 'A test template',
+    builtIn: false,
+    defaultPhases: [],
+    ...overrides,
+  }
+}
+
+function makeStep(overrides: Partial<ProtocolStepDefinition> = {}): ProtocolStepDefinition {
+  return {
+    id: 'step-1',
+    kind: 'present',
+    label: 'Step One',
+    ...overrides,
+  }
+}
+
+describe('templateToNodes — node creation', () => {
+  it('creates one node per step', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-1', label: 'Step One' }),
+      makeStep({ id: 'step-2', label: 'Step Two', kind: 'decide' }),
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ steps }))
+    assert.strictEqual(nodes.length, 2)
+    assert.deepStrictEqual(nodes.map((n) => n.id), ['step-1', 'step-2'])
+  })
+
+  it('sets correct node type from kind', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'phase-step', kind: 'present' }),
+      makeStep({ id: 'branch-step', kind: 'branch' }),
+      makeStep({ id: 'loop-step', kind: 'repeat' }),
+      makeStep({ id: 'parallel-step', kind: 'parallel' }),
+      makeStep({ id: 'join-step', kind: 'join' }),
+      makeStep({ id: 'complete-step', kind: 'complete' }),
+      makeStep({ id: 'foreach-step', kind: 'for_each' }),
+      makeStep({ id: 'subflow-step', kind: 'subflow' }),
+      makeStep({ id: 'swarm-step', kind: 'swarm_claim' }),
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ steps }))
+    const typeMap = Object.fromEntries(nodes.map((n) => [n.id, n.type]))
+    assert.strictEqual(typeMap['phase-step'], 'phase')
+    assert.strictEqual(typeMap['branch-step'], 'branch')
+    assert.strictEqual(typeMap['loop-step'], 'loop')
+    assert.strictEqual(typeMap['parallel-step'], 'parallel')
+    assert.strictEqual(typeMap['join-step'], 'join')
+    assert.strictEqual(typeMap['complete-step'], 'complete')
+    assert.strictEqual(typeMap['foreach-step'], 'forEach')
+    assert.strictEqual(typeMap['subflow-step'], 'subflow')
+    assert.strictEqual(typeMap['swarm-step'], 'swarm')
+  })
+
+  it('copies step data fields into node data', () => {
+    const step = makeStep({
+      id: 'step-1',
+      kind: 'decide',
+      label: 'My Step',
+      instructions: 'Do the thing',
+      turnLimit: 3,
+      completionCriteria: 'Done when X',
+      outputKey: 'result',
+      dependsOnStepIds: ['step-0'],
+    })
+    const { nodes } = templateToNodes(makeTemplate({ steps: [step] }))
+    const data = nodes[0].data
+    assert.strictEqual(data.label, 'My Step')
+    assert.strictEqual(data.kind, 'decide')
+    assert.strictEqual(data.instructions, 'Do the thing')
+    assert.strictEqual(data.turnLimit, 3)
+    assert.strictEqual(data.completionCriteria, 'Done when X')
+    assert.strictEqual(data.outputKey, 'result')
+    assert.deepStrictEqual(data.dependsOnStepIds, ['step-0'])
+  })
+})
+
+describe('templateToNodes — edge creation', () => {
+  it('creates a default edge from nextStepId', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-1', nextStepId: 'step-2' }),
+      makeStep({ id: 'step-2' }),
+    ]
+    const { edges } = templateToNodes(makeTemplate({ steps }))
+    assert.strictEqual(edges.length, 1)
+    const edge = edges[0]
+    assert.strictEqual(edge.id, 'step-1--step-2')
+    assert.strictEqual(edge.source, 'step-1')
+    assert.strictEqual(edge.target, 'step-2')
+    assert.strictEqual(edge.type, 'default')
+    assert.strictEqual(edge.data?.edgeType, 'default')
+  })
+
+  it('creates branch edges from branchCases', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({
+        id: 'branch-step',
+        kind: 'branch',
+        branchCases: [
+          { id: 'case-yes', label: 'Yes', nextStepId: 'step-yes' },
+          { id: 'case-no', label: 'No', nextStepId: 'step-no' },
+        ],
+      }),
+      makeStep({ id: 'step-yes' }),
+      makeStep({ id: 'step-no' }),
+    ]
+    const { edges } = templateToNodes(makeTemplate({ steps }))
+    const branchEdges = edges.filter((e) => e.data?.edgeType === 'branch')
+    assert.strictEqual(branchEdges.length, 2)
+
+    const yesEdge = branchEdges.find((e) => e.id === 'branch-step--case-yes')
+    assert.notStrictEqual(yesEdge, undefined)
+    assert.strictEqual(yesEdge?.source, 'branch-step')
+    assert.strictEqual(yesEdge?.target, 'step-yes')
+    assert.strictEqual(yesEdge?.sourceHandle, 'case-yes')
+    assert.strictEqual(yesEdge?.data?.branchCaseId, 'case-yes')
+    assert.strictEqual(yesEdge?.data?.label, 'Yes')
+
+    const noEdge = branchEdges.find((e) => e.id === 'branch-step--case-no')
+    assert.notStrictEqual(noEdge, undefined)
+    assert.strictEqual(noEdge?.target, 'step-no')
+  })
+
+  it('creates a branch edge for defaultNextStepId with label "Default"', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({
+        id: 'branch-step',
+        kind: 'branch',
+        branchCases: [
+          { id: 'case-a', label: 'Option A', nextStepId: 'step-a' },
+        ],
+        defaultNextStepId: 'step-default',
+      }),
+      makeStep({ id: 'step-a' }),
+      makeStep({ id: 'step-default' }),
+    ]
+    const { edges } = templateToNodes(makeTemplate({ steps }))
+    const defaultEdge = edges.find((e) => e.id === 'branch-step--default')
+    assert.notStrictEqual(defaultEdge, undefined)
+    assert.strictEqual(defaultEdge?.source, 'branch-step')
+    assert.strictEqual(defaultEdge?.target, 'step-default')
+    assert.strictEqual(defaultEdge?.sourceHandle, 'default')
+    assert.strictEqual(defaultEdge?.type, 'branch')
+    assert.strictEqual(defaultEdge?.label, 'Default')
+    assert.strictEqual(defaultEdge?.data?.edgeType, 'branch')
+    assert.strictEqual(defaultEdge?.data?.label, 'Default')
+  })
+
+  it('creates a loop edge from repeat.bodyStepId', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({
+        id: 'loop-step',
+        kind: 'repeat',
+        repeat: {
+          bodyStepId: 'body-step',
+          maxIterations: 5,
+        },
+      }),
+      makeStep({ id: 'body-step' }),
+    ]
+    const { edges } = templateToNodes(makeTemplate({ steps }))
+    const loopEdge = edges.find((e) => e.id === 'loop-step--loop')
+    assert.notStrictEqual(loopEdge, undefined)
+    assert.strictEqual(loopEdge?.source, 'loop-step')
+    assert.strictEqual(loopEdge?.target, 'body-step')
+    assert.strictEqual(loopEdge?.sourceHandle, 'loop-back')
+    assert.strictEqual(loopEdge?.type, 'loop')
+    assert.strictEqual(loopEdge?.data?.edgeType, 'loop')
+    assert.strictEqual(loopEdge?.data?.isLoopback, true)
+  })
+
+  it('creates no edges when steps have no connections', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-1' }),
+      makeStep({ id: 'step-2' }),
+    ]
+    const { edges } = templateToNodes(makeTemplate({ steps }))
+    assert.strictEqual(edges.length, 0)
+  })
+})
+
+describe('templateToNodes — fallback to defaultPhases', () => {
+  it('uses defaultPhases when steps is undefined', () => {
+    const phases: ProtocolPhaseDefinition[] = [
+      { id: 'phase-1', kind: 'present', label: 'Present' },
+      { id: 'phase-2', kind: 'decide', label: 'Decide' },
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ defaultPhases: phases }))
+    assert.strictEqual(nodes.length, 2)
+    assert.strictEqual(nodes[0].id, 'phase-1')
+    assert.strictEqual(nodes[1].id, 'phase-2')
+  })
+
+  it('uses defaultPhases when steps is an empty array', () => {
+    const phases: ProtocolPhaseDefinition[] = [
+      { id: 'phase-1', kind: 'summarize', label: 'Summarize' },
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ defaultPhases: phases, steps: [] }))
+    assert.strictEqual(nodes.length, 1)
+    assert.strictEqual(nodes[0].id, 'phase-1')
+  })
+
+  it('creates sequential edges between defaultPhases', () => {
+    const phases: ProtocolPhaseDefinition[] = [
+      { id: 'phase-1', kind: 'present', label: 'Present' },
+      { id: 'phase-2', kind: 'decide', label: 'Decide' },
+      { id: 'phase-3', kind: 'summarize', label: 'Summarize' },
+    ]
+    const { edges } = templateToNodes(makeTemplate({ defaultPhases: phases }))
+    assert.strictEqual(edges.length, 2)
+    assert.strictEqual(edges[0].id, 'phase-1--phase-2')
+    assert.strictEqual(edges[0].source, 'phase-1')
+    assert.strictEqual(edges[0].target, 'phase-2')
+    assert.strictEqual(edges[1].id, 'phase-2--phase-3')
+    assert.strictEqual(edges[1].source, 'phase-2')
+    assert.strictEqual(edges[1].target, 'phase-3')
+  })
+
+  it('copies phase data fields into node data', () => {
+    const phases: ProtocolPhaseDefinition[] = [
+      {
+        id: 'phase-1',
+        kind: 'present',
+        label: 'Present Phase',
+        instructions: 'Do the presentation',
+        turnLimit: 2,
+        completionCriteria: 'All presented',
+      },
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ defaultPhases: phases }))
+    const data = nodes[0].data
+    assert.strictEqual(data.label, 'Present Phase')
+    assert.strictEqual(data.kind, 'present')
+    assert.strictEqual(data.instructions, 'Do the presentation')
+    assert.strictEqual(data.turnLimit, 2)
+    assert.strictEqual(data.completionCriteria, 'All presented')
+  })
+
+  it('uses steps when both steps and defaultPhases are present and steps is non-empty', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-1', label: 'The Step' }),
+    ]
+    const phases: ProtocolPhaseDefinition[] = [
+      { id: 'phase-1', kind: 'present', label: 'The Phase' },
+    ]
+    const { nodes } = templateToNodes(makeTemplate({ steps, defaultPhases: phases }))
+    assert.strictEqual(nodes.length, 1)
+    assert.strictEqual(nodes[0].id, 'step-1')
+  })
+})

package/src/features/protocols/builder/utils/template-to-nodes.ts

@@ -0,0 +1,169 @@
+import type { Node, Edge } from '@xyflow/react'
+import type { ProtocolTemplate, ProtocolStepKind, ProtocolStepDefinition, ProtocolPhaseDefinition } from '@/types'
+import type { BuilderNodeData, BuilderEdgeData } from '../protocol-builder-store'
+
+export function getNodeTypeForKind(kind: ProtocolStepKind): string {
+  switch (kind) {
+    case 'branch':
+      return 'branch'
+    case 'repeat':
+      return 'loop'
+    case 'parallel':
+      return 'parallel'
+    case 'join':
+      return 'join'
+    case 'for_each':
+      return 'forEach'
+    case 'subflow':
+      return 'subflow'
+    case 'swarm_claim':
+      return 'swarm'
+    case 'complete':
+      return 'complete'
+    default:
+      // All ProtocolPhaseKind values map to 'phase'
+      return 'phase'
+  }
+}
+
+function stepToNode(step: ProtocolStepDefinition): Node<BuilderNodeData> {
+  return {
+    id: step.id,
+    type: getNodeTypeForKind(step.kind),
+    position: { x: 0, y: 0 },
+    data: {
+      label: step.label,
+      kind: step.kind,
+      instructions: step.instructions ?? null,
+      turnLimit: step.turnLimit ?? null,
+      completionCriteria: step.completionCriteria ?? null,
+      taskConfig: step.taskConfig ?? null,
+      delegationConfig: step.delegationConfig ?? null,
+      repeat: step.repeat ?? null,
+      parallel: step.parallel ?? null,
+      join: step.join ?? null,
+      forEach: step.forEach ?? null,
+      subflow: step.subflow ?? null,
+      swarm: step.swarm ?? null,
+      branchCases: step.branchCases,
+      defaultNextStepId: step.defaultNextStepId ?? null,
+      outputKey: step.outputKey ?? null,
+      dependsOnStepIds: step.dependsOnStepIds,
+    },
+  }
+}
+
+function phaseToNode(phase: ProtocolPhaseDefinition): Node<BuilderNodeData> {
+  return {
+    id: phase.id,
+    type: getNodeTypeForKind(phase.kind),
+    position: { x: 0, y: 0 },
+    data: {
+      label: phase.label,
+      kind: phase.kind,
+      instructions: phase.instructions ?? null,
+      turnLimit: phase.turnLimit ?? null,
+      completionCriteria: phase.completionCriteria ?? null,
+      taskConfig: phase.taskConfig ?? null,
+      delegationConfig: phase.delegationConfig ?? null,
+    },
+  }
+}
+
+export interface TemplateToNodesResult {
+  nodes: Node<BuilderNodeData>[]
+  edges: Edge<BuilderEdgeData>[]
+}
+
+export function templateToNodes(template: ProtocolTemplate): TemplateToNodesResult {
+  const useSteps = Array.isArray(template.steps) && template.steps.length > 0
+
+  if (!useSteps) {
+    // Fall back to defaultPhases — phases have no edge wiring defined, so connect them sequentially
+    const nodes = template.defaultPhases.map(phaseToNode)
+    const edges: Edge<BuilderEdgeData>[] = []
+
+    for (let i = 0; i < template.defaultPhases.length - 1; i++) {
+      const source = template.defaultPhases[i]
+      const target = template.defaultPhases[i + 1]
+      edges.push({
+        id: `${source.id}--${target.id}`,
+        source: source.id,
+        target: target.id,
+        type: 'default',
+        data: { edgeType: 'default' },
+      })
+    }
+
+    return { nodes, edges }
+  }
+
+  const steps = template.steps!
+  const nodes = steps.map(stepToNode)
+  const edges: Edge<BuilderEdgeData>[] = []
+
+  for (const step of steps) {
+    // Default next step edge
+    if (step.nextStepId) {
+      edges.push({
+        id: `${step.id}--${step.nextStepId}`,
+        source: step.id,
+        target: step.nextStepId,
+        type: 'default',
+        data: { edgeType: 'default' },
+      })
+    }
+
+    // Branch case edges
+    if (step.branchCases && step.branchCases.length > 0) {
+      for (const branchCase of step.branchCases) {
+        edges.push({
+          id: `${step.id}--${branchCase.id}`,
+          source: step.id,
+          target: branchCase.nextStepId,
+          sourceHandle: branchCase.id,
+          type: 'branch',
+          label: branchCase.label,
+          data: {
+            edgeType: 'branch',
+            branchCaseId: branchCase.id,
+            label: branchCase.label,
+          },
+        })
+      }
+    }
+
+    // Default branch edge (for branch steps)
+    if (step.defaultNextStepId) {
+      edges.push({
+        id: `${step.id}--default`,
+        source: step.id,
+        target: step.defaultNextStepId,
+        sourceHandle: 'default',
+        type: 'branch',
+        label: 'Default',
+        data: {
+          edgeType: 'branch',
+          label: 'Default',
+        },
+      })
+    }
+
+    // Loop body edge
+    if (step.repeat?.bodyStepId) {
+      edges.push({
+        id: `${step.id}--loop`,
+        source: step.id,
+        target: step.repeat.bodyStepId,
+        sourceHandle: 'loop-back',
+        type: 'loop',
+        data: {
+          edgeType: 'loop',
+          isLoopback: true,
+        },
+      })
+    }
+  }
+
+  return { nodes, edges }
+}

package/src/features/protocols/builder/validators/dag-validator.test.ts

@@ -0,0 +1,150 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { BuilderNode, BuilderEdge } from '../protocol-builder-store'
+import type { ProtocolStepKind } from '../../../../types'
+import { getReachableNodes, validateDAG } from './dag-validator'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeNode(id: string, kind: ProtocolStepKind = 'present', label?: string): BuilderNode {
+  return {
+    id,
+    type: 'builderNode',
+    position: { x: 0, y: 0 },
+    data: {
+      label: label ?? id,
+      kind,
+    },
+  } as BuilderNode
+}
+
+function makeEdge(source: string, target: string, edgeType: 'default' | 'branch' | 'loop' = 'default'): BuilderEdge {
+  return {
+    id: `${source}->${target}`,
+    source,
+    target,
+    data: {
+      edgeType,
+    },
+  } as BuilderEdge
+}
+
+// ---------------------------------------------------------------------------
+// getReachableNodes
+// ---------------------------------------------------------------------------
+
+describe('getReachableNodes', () => {
+  it('returns all connected nodes from start', () => {
+    const edges: BuilderEdge[] = [
+      makeEdge('a', 'b'),
+      makeEdge('b', 'c'),
+      makeEdge('c', 'd'),
+    ]
+    const result = getReachableNodes('a', edges, ['a', 'b', 'c', 'd'])
+    assert.deepStrictEqual(result, new Set(['a', 'b', 'c', 'd']))
+  })
+
+  it('excludes disconnected nodes', () => {
+    const edges: BuilderEdge[] = [
+      makeEdge('a', 'b'),
+    ]
+    const result = getReachableNodes('a', edges, ['a', 'b', 'c'])
+    assert.strictEqual(result.has('c'), false)
+    assert.deepStrictEqual(result, new Set(['a', 'b']))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// validateDAG
+// ---------------------------------------------------------------------------
+
+describe('validateDAG', () => {
+  it('returns empty errors and warnings for an empty graph', () => {
+    const { errors, warnings } = validateDAG([], [])
+    assert.strictEqual(errors.length, 0)
+    assert.strictEqual(warnings.length, 0)
+  })
+
+  it('valid linear graph has no errors', () => {
+    const nodes = [makeNode('a'), makeNode('b'), makeNode('c', 'complete')]
+    const edges = [makeEdge('a', 'b'), makeEdge('b', 'c')]
+    const { errors } = validateDAG(nodes, edges)
+    assert.strictEqual(errors.length, 0)
+  })
+
+  it('detects orphan nodes (not connected to any edge)', () => {
+    const nodes = [makeNode('entry'), makeNode('orphan', 'present', 'Orphan'), makeNode('end', 'complete')]
+    const edges = [makeEdge('entry', 'end')]
+    const { errors } = validateDAG(nodes, edges)
+    const orphanError = errors.find((e) => e.nodeId === 'orphan')
+    assert.notStrictEqual(orphanError, undefined)
+    assert.ok(orphanError?.message.includes('not connected to any edge'))
+  })
+
+  it('detects unreachable nodes (connected but not reachable from entry)', () => {
+    // 'island' has an edge but points away from entry; entry cannot reach it
+    const nodes = [makeNode('entry'), makeNode('middle'), makeNode('island'), makeNode('end', 'complete')]
+    const edges = [
+      makeEdge('entry', 'middle'),
+      makeEdge('middle', 'end'),
+      makeEdge('island', 'end'), // island has an edge but isn't reachable from entry
+    ]
+    const { errors } = validateDAG(nodes, edges)
+    const unreachableError = errors.find((e) => e.nodeId === 'island')
+    assert.notStrictEqual(unreachableError, undefined)
+    assert.ok(unreachableError?.message.includes('not reachable from the entry node'))
+  })
+
+  it('warns about nodes with no outgoing edge', () => {
+    const nodes = [makeNode('entry'), makeNode('dead-end', 'present', 'Dead End')]
+    const edges = [makeEdge('entry', 'dead-end')]
+    const { warnings } = validateDAG(nodes, edges)
+    const deadEndWarning = warnings.find((w) => w.nodeId === 'dead-end')
+    assert.notStrictEqual(deadEndWarning, undefined)
+    assert.ok(deadEndWarning?.message.includes('no outgoing edge'))
+  })
+
+  it('does not warn about complete nodes with no outgoing edge', () => {
+    const nodes = [makeNode('entry'), makeNode('done', 'complete', 'Done')]
+    const edges = [makeEdge('entry', 'done')]
+    const { warnings } = validateDAG(nodes, edges)
+    const completeWarning = warnings.find((w) => w.nodeId === 'done')
+    assert.strictEqual(completeWarning, undefined)
+  })
+
+  it('detects branch cases without target edges', () => {
+    const branchNode: BuilderNode = {
+      id: 'branch1',
+      type: 'builderNode',
+      position: { x: 0, y: 0 },
+      data: {
+        label: 'My Branch',
+        kind: 'branch',
+        branchCases: [
+          { id: 'case-yes', label: 'Yes', nextStepId: 'nodeYes' },
+          { id: 'case-no', label: 'No', nextStepId: 'nodeNo' },
+        ],
+      },
+    } as BuilderNode
+
+    // Only provide an edge for case-yes, not case-no
+    const yesEdge: BuilderEdge = {
+      id: 'branch1->nodeYes',
+      source: 'branch1',
+      target: 'nodeYes',
+      data: { edgeType: 'branch', branchCaseId: 'case-yes' },
+    } as BuilderEdge
+
+    const nodes = [makeNode('entry'), branchNode, makeNode('nodeYes', 'complete'), makeNode('nodeNo', 'complete')]
+    const edges = [makeEdge('entry', 'branch1'), yesEdge, makeEdge('nodeYes', 'nodeNo')]
+
+    const { errors } = validateDAG(nodes, edges)
+    const branchError = errors.find((e) => e.nodeId === 'branch1' && e.message.includes('No'))
+    assert.notStrictEqual(branchError, undefined)
+    // Should not flag case-yes since it has an edge
+    const yesError = errors.find((e) => e.nodeId === 'branch1' && e.message.includes('Yes'))
+    assert.strictEqual(yesError, undefined)
+  })
+})