@elevasis/core 0.7.1 → 0.8.0

package/src/organization-model/__tests__/graph.test.ts

@@ -1,894 +1,894 @@
-import { describe, expect, it } from 'vitest'
-import { buildOrganizationGraph } from '../graph'
-import { defineOrganizationModel, resolveOrganizationModel } from '../resolve'
-
-describe('organization-graph', () => {
-  it('derives semantic graph nodes and edges from the organization model', () => {
-    const model = resolveOrganizationModel(
-      defineOrganizationModel({
-        branding: {
-          organizationName: 'Acme',
-          productName: 'Acme OS',
-          shortName: 'Acme'
-        }
-      })
-    )
-
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(graph.version).toBe(1)
-    expect(graph.organizationModelVersion).toBe(1)
-
-    const feature = graph.nodes.find((node) => node.id === 'feature:operations')
-    expect(feature).toMatchObject({
-      kind: 'feature',
-      sourceId: 'operations',
-      label: 'Operations',
-      enabled: true,
-      featureId: 'operations'
-    })
-
-    const disabledFeature = graph.nodes.find((node) => node.id === 'feature:seo')
-    expect(disabledFeature).toMatchObject({
-      kind: 'feature',
-      sourceId: 'seo',
-      enabled: false
-    })
-
-    // Features now carry semantic data directly (no separate domain nodes)
-    const crmFeature = graph.nodes.find((node) => node.id === 'feature:crm')
-    expect(crmFeature).toMatchObject({
-      kind: 'feature',
-      sourceId: 'crm',
-      label: 'CRM'
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'surface:crm.pipeline')).toMatchObject({
-      kind: 'surface',
-      sourceId: 'crm.pipeline',
-      surfaceType: 'graph'
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'entity:crm.deal')).toMatchObject({
-      kind: 'entity',
-      sourceId: 'crm.deal',
-      label: 'crm.deal'
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'capability:crm.pipeline.manage')).toMatchObject({
-      kind: 'capability',
-      sourceId: 'crm.pipeline.manage',
-      label: 'crm.pipeline.manage'
-    })
-
-    expect(graph.edges).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          kind: 'contains',
-          sourceId: 'organization-model',
-          targetId: 'feature:crm'
-        }),
-        expect.objectContaining({
-          kind: 'exposes',
-          sourceId: 'feature:crm',
-          targetId: 'surface:crm.pipeline'
-        }),
-        expect.objectContaining({
-          kind: 'references',
-          sourceId: 'surface:crm.pipeline',
-          targetId: 'feature:crm'
-        })
-      ])
-    )
-  })
-
-  describe('feature labels', () => {
-    it('uses the feature label directly from the unified features array', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
-        })
-      )
-
-      const graph = buildOrganizationGraph({ organizationModel: model })
-
-      // Verify all default features have their labels from the unified feature definitions
-      const expectedLabels: Record<string, string> = {
-        crm: 'CRM',
-        'lead-gen': 'Lead Gen',
-        projects: 'Projects',
-        operations: 'Operations',
-        monitoring: 'Monitoring',
-        settings: 'Settings',
-        seo: 'SEO'
-      }
-
-      for (const [featureId, expectedLabel] of Object.entries(expectedLabels)) {
-        const node = graph.nodes.find((n) => n.id === `feature:${featureId}`)
-        expect(node, `feature node for '${featureId}' should exist`).toBeDefined()
-        expect(node?.label).toBe(expectedLabel)
-      }
-    })
-
-    it('uses the overridden label when a feature label is customized', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
-          features: [
-            {
-              id: 'crm',
-              label: 'Deals',
-              enabled: true,
-              entityIds: [],
-              surfaceIds: ['crm.pipeline'],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'crm.pipeline',
-            surfaces: [
-              {
-                id: 'crm.pipeline',
-                label: 'Pipeline',
-                path: '/crm/pipeline',
-                surfaceType: 'graph',
-                featureId: 'crm',
-                featureIds: ['crm'],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({ organizationModel: model })
-
-      const node = graph.nodes.find((n) => n.id === 'feature:crm')
-      expect(node?.label).toBe('Deals')
-    })
-  })
-
-  describe('resource node upsert merging', () => {
-    it('keeps resourceMappings label and merges description from commandViewData', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'operations',
-              label: 'Operations',
-              enabled: true,
-              color: 'violet',
-              entityIds: [],
-              surfaceIds: ['operations.command-view'],
-              resourceIds: ['workflow-order'],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'operations.command-view',
-            surfaces: [
-              {
-                id: 'operations.command-view',
-                label: 'Command View',
-                path: '/operations/command-view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: ['operations'],
-                entityIds: [],
-                resourceIds: ['workflow-order'],
-                capabilityIds: []
-              }
-            ],
-            groups: [
-              {
-                id: 'primary-operations',
-                label: 'Operations',
-                placement: 'primary',
-                surfaceIds: ['operations.command-view']
-              }
-            ]
-          },
-          resourceMappings: [
-            {
-              id: 'workflow-order-model',
-              label: 'Order Workflow',
-              resourceId: 'workflow-order',
-              resourceType: 'workflow',
-              featureIds: ['operations'],
-              entityIds: [],
-              surfaceIds: ['operations.command-view'],
-              capabilityIds: []
-            }
-          ]
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [
-            {
-              resourceId: 'workflow-order',
-              name: 'Order Workflow Runtime',
-              description: 'Runtime description from commandViewData',
-              version: '1.0.0',
-              type: 'workflow',
-              status: 'prod',
-              domains: ['operations'],
-              stepCount: 2,
-              entryPoint: 'start'
-            }
-          ],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [],
-          edges: []
-        }
-      })
-
-      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:workflow-order')
-      expect(resourceNodes).toHaveLength(1)
-
-      const node = resourceNodes[0]
-      expect(node.label).toBe('Order Workflow')
-      expect(node.description).toBe('Runtime description from commandViewData')
-    })
-
-    it('preserves existing non-default label even when commandViewData provides a different name', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'ops',
-              label: 'Ops',
-              enabled: true,
-              color: 'blue',
-              entityIds: [],
-              surfaceIds: ['ops.view'],
-              resourceIds: ['res-a'],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'ops.view',
-            surfaces: [
-              {
-                id: 'ops.view',
-                label: 'Ops View',
-                path: '/ops/view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: ['ops'],
-                entityIds: [],
-                resourceIds: ['res-a'],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
-          },
-          resourceMappings: [
-            {
-              id: 'res-a-model',
-              label: 'My Custom Label',
-              resourceId: 'res-a',
-              resourceType: 'workflow',
-              featureIds: ['ops'],
-              entityIds: [],
-              surfaceIds: ['ops.view'],
-              capabilityIds: []
-            }
-          ]
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [
-            {
-              resourceId: 'res-a',
-              name: 'Runtime Name Should Not Override',
-              description: 'desc',
-              version: '1.0.0',
-              type: 'workflow',
-              status: 'prod',
-              domains: ['ops'],
-              stepCount: 1,
-              entryPoint: 'start'
-            }
-          ],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [],
-          edges: []
-        }
-      })
-
-      const node = graph.nodes.find((n) => n.id === 'resource:res-a')
-      expect(node?.label).toBe('My Custom Label')
-    })
-  })
-
-  describe('de-duplication of graph elements', () => {
-    it('creates only one feature node when multiple surfaces reference the same feature', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'crm',
-              label: 'CRM',
-              enabled: true,
-              color: 'blue',
-              entityIds: [],
-              surfaceIds: ['crm.pipeline', 'crm.accounts'],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'crm.pipeline',
-            surfaces: [
-              {
-                id: 'crm.pipeline',
-                label: 'Pipeline',
-                path: '/crm/pipeline',
-                surfaceType: 'graph',
-                featureId: 'crm',
-                featureIds: ['crm'],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              },
-              {
-                id: 'crm.accounts',
-                label: 'Accounts',
-                path: '/crm/accounts',
-                surfaceType: 'list',
-                featureId: 'crm',
-                featureIds: ['crm'],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline', 'crm.accounts'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({ organizationModel: model })
-
-      const featureNodes = graph.nodes.filter((n) => n.id === 'feature:crm')
-      expect(featureNodes).toHaveLength(1)
-    })
-
-    it('creates only one entity node when the same entity appears in both a feature and a surface', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'crm',
-              label: 'CRM',
-              enabled: true,
-              color: 'blue',
-              entityIds: ['crm.deal'],
-              surfaceIds: ['crm.pipeline'],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'crm.pipeline',
-            surfaces: [
-              {
-                id: 'crm.pipeline',
-                label: 'Pipeline',
-                path: '/crm/pipeline',
-                surfaceType: 'graph',
-                featureId: 'crm',
-                featureIds: ['crm'],
-                entityIds: ['crm.deal'],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({ organizationModel: model })
-
-      const entityNodes = graph.nodes.filter((n) => n.id === 'entity:crm.deal')
-      expect(entityNodes).toHaveLength(1)
-    })
-
-    it('creates only one resource node when the same resource appears in resourceMappings and commandViewData', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'ops',
-              label: 'Ops',
-              enabled: true,
-              color: 'violet',
-              entityIds: [],
-              surfaceIds: ['ops.view'],
-              resourceIds: ['wf-shared'],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'ops.view',
-            surfaces: [
-              {
-                id: 'ops.view',
-                label: 'Ops View',
-                path: '/ops/view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: ['ops'],
-                entityIds: [],
-                resourceIds: ['wf-shared'],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
-          },
-          resourceMappings: [
-            {
-              id: 'wf-shared-model',
-              label: 'Shared Workflow',
-              resourceId: 'wf-shared',
-              resourceType: 'workflow',
-              featureIds: ['ops'],
-              entityIds: [],
-              surfaceIds: ['ops.view'],
-              capabilityIds: []
-            }
-          ]
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [
-            {
-              resourceId: 'wf-shared',
-              name: 'Shared Workflow Runtime',
-              description: 'desc',
-              version: '1.0.0',
-              type: 'workflow',
-              status: 'prod',
-              domains: ['ops'],
-              stepCount: 1,
-              entryPoint: 'start'
-            }
-          ],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [],
-          edges: []
-        }
-      })
-
-      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:wf-shared')
-      expect(resourceNodes).toHaveLength(1)
-    })
-  })
-
-  describe('commandViewData edge relationships', () => {
-    it('creates a stub resource node with label === resourceId for edges referencing unknown resources', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'ops',
-              label: 'Ops',
-              enabled: true,
-              color: 'violet',
-              entityIds: [],
-              surfaceIds: [],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'ops.view',
-            surfaces: [
-              {
-                id: 'ops.view',
-                label: 'Ops View',
-                path: '/ops/view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: [],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [],
-          edges: [
-            {
-              id: 'edge-unknown',
-              source: 'unknown-source',
-              target: 'unknown-target',
-              relationship: 'triggers'
-            }
-          ]
-        }
-      })
-
-      const sourceNode = graph.nodes.find((n) => n.id === 'resource:unknown-source')
-      expect(sourceNode).toBeDefined()
-      expect(sourceNode?.label).toBe('unknown-source')
-      expect(sourceNode?.sourceId).toBe('unknown-source')
-
-      const targetNode = graph.nodes.find((n) => n.id === 'resource:unknown-target')
-      expect(targetNode).toBeDefined()
-      expect(targetNode?.label).toBe('unknown-target')
-      expect(targetNode?.sourceId).toBe('unknown-target')
-    })
-
-    it('normalizes humanCheckpoints type to human_checkpoint on resource nodes', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'ops',
-              label: 'Ops',
-              enabled: true,
-              color: 'violet',
-              entityIds: [],
-              surfaceIds: [],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'ops.view',
-            surfaces: [
-              {
-                id: 'ops.view',
-                label: 'Ops View',
-                path: '/ops/view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: [],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [
-            {
-              resourceId: 'approval-step',
-              name: 'Approval Step',
-              description: 'Human review gate',
-              version: '1.0.0',
-              type: 'human',
-              status: 'prod',
-              domains: ['ops']
-            }
-          ],
-          edges: []
-        }
-      })
-
-      const node = graph.nodes.find((n) => n.id === 'resource:approval-step')
-      expect(node).toBeDefined()
-      expect(node?.resourceType).toBe('human_checkpoint')
-    })
-
-    it('creates a references edge with label and relationshipType for commandViewData edges', () => {
-      const model = resolveOrganizationModel(
-        defineOrganizationModel({
-          features: [
-            {
-              id: 'ops',
-              label: 'Ops',
-              enabled: true,
-              color: 'violet',
-              entityIds: [],
-              surfaceIds: [],
-              resourceIds: [],
-              capabilityIds: []
-            }
-          ],
-          navigation: {
-            defaultSurfaceId: 'ops.view',
-            surfaces: [
-              {
-                id: 'ops.view',
-                label: 'Ops View',
-                path: '/ops/view',
-                surfaceType: 'graph',
-                featureId: 'operations',
-                featureIds: [],
-                entityIds: [],
-                resourceIds: [],
-                capabilityIds: []
-              }
-            ],
-            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
-          }
-        })
-      )
-
-      const graph = buildOrganizationGraph({
-        organizationModel: model,
-        commandViewData: {
-          workflows: [],
-          agents: [],
-          triggers: [],
-          integrations: [],
-          externalResources: [],
-          humanCheckpoints: [],
-          edges: [
-            {
-              id: 'edge-triggers',
-              source: 'svc-a',
-              target: 'svc-b',
-              relationship: 'triggers'
-            }
-          ]
-        }
-      })
-
-      expect(graph.edges).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            kind: 'references',
-            sourceId: 'resource:svc-a',
-            targetId: 'resource:svc-b',
-            label: 'triggers',
-            relationshipType: 'triggers'
-          })
-        ])
-      )
-    })
-  })
-
-  it('bridges command view topology into resource nodes and labeled relationship edges', () => {
-    const model = resolveOrganizationModel(
-      defineOrganizationModel({
-        features: [
-          {
-            id: 'operations',
-            label: 'Operations',
-            description: 'Operational resources, topology, and orchestration visibility',
-            enabled: true,
-            color: 'violet',
-            entityIds: [],
-            surfaceIds: ['operations.command-view'],
-            resourceIds: ['workflow-order'],
-            capabilityIds: ['operations.command-view']
-          }
-        ],
-        navigation: {
-          defaultSurfaceId: 'operations.command-view',
-          surfaces: [
-            {
-              id: 'operations.command-view',
-              label: 'Command View',
-              path: '/operations/command-view',
-              surfaceType: 'graph',
-              featureId: 'operations',
-              featureIds: ['operations'],
-              entityIds: [],
-              resourceIds: ['workflow-order'],
-              capabilityIds: ['operations.command-view']
-            }
-          ],
-          groups: [
-            {
-              id: 'primary-operations',
-              label: 'Operations',
-              placement: 'primary',
-              surfaceIds: ['operations.command-view']
-            }
-          ]
-        },
-        resourceMappings: [
-          {
-            id: 'workflow-order-model',
-            label: 'Order Workflow Model',
-            resourceId: 'workflow-order',
-            resourceType: 'workflow',
-            featureIds: ['operations'],
-            entityIds: [],
-            surfaceIds: ['operations.command-view'],
-            capabilityIds: []
-          }
-        ]
-      })
-    )
-
-    const graph = buildOrganizationGraph({
-      organizationModel: model,
-      commandViewData: {
-        workflows: [
-          {
-            resourceId: 'workflow-order',
-            name: 'Order Workflow Runtime',
-            description: 'Runtime workflow surfaced by Command View',
-            version: '1.0.0',
-            type: 'workflow',
-            status: 'prod',
-            domains: ['operations'],
-            stepCount: 3,
-            entryPoint: 'start'
-          }
-        ],
-        agents: [
-          {
-            resourceId: 'agent-order',
-            name: 'Order Agent Runtime',
-            description: 'Runtime agent surfaced by Command View',
-            version: '1.0.0',
-            type: 'agent',
-            status: 'prod',
-            domains: ['operations'],
-            modelProvider: 'openai',
-            modelId: 'gpt-4.1',
-            toolCount: 2,
-            hasKnowledgeMap: true,
-            hasMemory: false,
-            sessionCapable: true
-          }
-        ],
-        triggers: [],
-        integrations: [
-          {
-            resourceId: 'integration-stripe',
-            name: 'Stripe Runtime',
-            description: 'Runtime integration surfaced by Command View',
-            version: '1.0.0',
-            type: 'integration',
-            status: 'prod',
-            domains: ['operations'],
-            provider: 'stripe',
-            credentialName: 'stripe-prod'
-          }
-        ],
-        externalResources: [],
-        humanCheckpoints: [
-          {
-            resourceId: 'approval-high-value',
-            name: 'High Value Approval',
-            description: 'Runtime human checkpoint surfaced by Command View',
-            version: '1.0.0',
-            type: 'human',
-            status: 'prod',
-            domains: ['operations']
-          }
-        ],
-        edges: [
-          {
-            id: 'edge-runtime-triggers',
-            source: 'agent-order',
-            target: 'workflow-order',
-            relationship: 'triggers'
-          },
-          {
-            id: 'edge-runtime-uses',
-            source: 'workflow-order',
-            target: 'integration-stripe',
-            relationship: 'uses'
-          },
-          {
-            id: 'edge-runtime-approval',
-            source: 'workflow-order',
-            target: 'approval-high-value',
-            relationship: 'approval'
-          }
-        ]
-      }
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'resource:workflow-order')).toMatchObject({
-      kind: 'resource',
-      sourceId: 'workflow-order',
-      resourceType: 'workflow',
-      label: 'Order Workflow Model'
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'resource:agent-order')).toMatchObject({
-      kind: 'resource',
-      sourceId: 'agent-order',
-      resourceType: 'agent',
-      label: 'Order Agent Runtime'
-    })
-
-    expect(graph.nodes.find((node) => node.id === 'resource:approval-high-value')).toMatchObject({
-      kind: 'resource',
-      sourceId: 'approval-high-value',
-      resourceType: 'human_checkpoint',
-      label: 'High Value Approval'
-    })
-
-    expect(graph.edges).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          kind: 'contains',
-          sourceId: 'organization-model',
-          targetId: 'resource:agent-order'
-        }),
-        expect.objectContaining({
-          kind: 'references',
-          sourceId: 'resource:agent-order',
-          targetId: 'feature:operations'
-        }),
-        expect.objectContaining({
-          kind: 'references',
-          sourceId: 'resource:agent-order',
-          targetId: 'resource:workflow-order',
-          label: 'triggers',
-          relationshipType: 'triggers'
-        }),
-        expect.objectContaining({
-          kind: 'references',
-          sourceId: 'resource:workflow-order',
-          targetId: 'resource:integration-stripe',
-          label: 'uses',
-          relationshipType: 'uses'
-        }),
-        expect.objectContaining({
-          kind: 'references',
-          sourceId: 'resource:workflow-order',
-          targetId: 'resource:approval-high-value',
-          label: 'approval',
-          relationshipType: 'approval'
-        }),
-        expect.objectContaining({
-          kind: 'maps_to',
-          sourceId: 'resource:workflow-order',
-          targetId: 'feature:operations'
-        }),
-        expect.objectContaining({
-          kind: 'maps_to',
-          sourceId: 'resource:workflow-order',
-          targetId: 'surface:operations.command-view'
-        })
-      ])
-    )
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { buildOrganizationGraph } from '../graph'
+import { defineOrganizationModel, resolveOrganizationModel } from '../resolve'
+
+describe('organization-graph', () => {
+  it('derives semantic graph nodes and edges from the organization model', () => {
+    const model = resolveOrganizationModel(
+      defineOrganizationModel({
+        branding: {
+          organizationName: 'Acme',
+          productName: 'Acme OS',
+          shortName: 'Acme'
+        }
+      })
+    )
+
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.version).toBe(1)
+    expect(graph.organizationModelVersion).toBe(1)
+
+    const feature = graph.nodes.find((node) => node.id === 'feature:operations')
+    expect(feature).toMatchObject({
+      kind: 'feature',
+      sourceId: 'operations',
+      label: 'Operations',
+      enabled: true,
+      featureId: 'operations'
+    })
+
+    const disabledFeature = graph.nodes.find((node) => node.id === 'feature:seo')
+    expect(disabledFeature).toMatchObject({
+      kind: 'feature',
+      sourceId: 'seo',
+      enabled: false
+    })
+
+    // Features now carry semantic data directly (no separate domain nodes)
+    const crmFeature = graph.nodes.find((node) => node.id === 'feature:crm')
+    expect(crmFeature).toMatchObject({
+      kind: 'feature',
+      sourceId: 'crm',
+      label: 'CRM'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'surface:crm.pipeline')).toMatchObject({
+      kind: 'surface',
+      sourceId: 'crm.pipeline',
+      surfaceType: 'graph'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'entity:crm.deal')).toMatchObject({
+      kind: 'entity',
+      sourceId: 'crm.deal',
+      label: 'crm.deal'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'capability:crm.pipeline.manage')).toMatchObject({
+      kind: 'capability',
+      sourceId: 'crm.pipeline.manage',
+      label: 'crm.pipeline.manage'
+    })
+
+    expect(graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: 'contains',
+          sourceId: 'organization-model',
+          targetId: 'feature:crm'
+        }),
+        expect.objectContaining({
+          kind: 'exposes',
+          sourceId: 'feature:crm',
+          targetId: 'surface:crm.pipeline'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'surface:crm.pipeline',
+          targetId: 'feature:crm'
+        })
+      ])
+    )
+  })
+
+  describe('feature labels', () => {
+    it('uses the feature label directly from the unified features array', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      // Verify all default features have their labels from the unified feature definitions
+      const expectedLabels: Record<string, string> = {
+        crm: 'CRM',
+        'lead-gen': 'Lead Gen',
+        projects: 'Projects',
+        operations: 'Operations',
+        monitoring: 'Monitoring',
+        settings: 'Settings',
+        seo: 'SEO'
+      }
+
+      for (const [featureId, expectedLabel] of Object.entries(expectedLabels)) {
+        const node = graph.nodes.find((n) => n.id === `feature:${featureId}`)
+        expect(node, `feature node for '${featureId}' should exist`).toBeDefined()
+        expect(node?.label).toBe(expectedLabel)
+      }
+    })
+
+    it('uses the overridden label when a feature label is customized', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
+          features: [
+            {
+              id: 'crm',
+              label: 'Deals',
+              enabled: true,
+              entityIds: [],
+              surfaceIds: ['crm.pipeline'],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'crm.pipeline',
+            surfaces: [
+              {
+                id: 'crm.pipeline',
+                label: 'Pipeline',
+                path: '/crm/pipeline',
+                surfaceType: 'graph',
+                featureId: 'crm',
+                featureIds: ['crm'],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const node = graph.nodes.find((n) => n.id === 'feature:crm')
+      expect(node?.label).toBe('Deals')
+    })
+  })
+
+  describe('resource node upsert merging', () => {
+    it('keeps resourceMappings label and merges description from commandViewData', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'operations',
+              label: 'Operations',
+              enabled: true,
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: ['operations.command-view'],
+              resourceIds: ['workflow-order'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'operations.command-view',
+            surfaces: [
+              {
+                id: 'operations.command-view',
+                label: 'Command View',
+                path: '/operations/command-view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: ['operations'],
+                entityIds: [],
+                resourceIds: ['workflow-order'],
+                capabilityIds: []
+              }
+            ],
+            groups: [
+              {
+                id: 'primary-operations',
+                label: 'Operations',
+                placement: 'primary',
+                surfaceIds: ['operations.command-view']
+              }
+            ]
+          },
+          resourceMappings: [
+            {
+              id: 'workflow-order-model',
+              label: 'Order Workflow',
+              resourceId: 'workflow-order',
+              resourceType: 'workflow',
+              featureIds: ['operations'],
+              entityIds: [],
+              surfaceIds: ['operations.command-view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'workflow-order',
+              name: 'Order Workflow Runtime',
+              description: 'Runtime description from commandViewData',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['operations'],
+              stepCount: 2,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:workflow-order')
+      expect(resourceNodes).toHaveLength(1)
+
+      const node = resourceNodes[0]
+      expect(node.label).toBe('Order Workflow')
+      expect(node.description).toBe('Runtime description from commandViewData')
+    })
+
+    it('preserves existing non-default label even when commandViewData provides a different name', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              enabled: true,
+              color: 'blue',
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              resourceIds: ['res-a'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: ['ops'],
+                entityIds: [],
+                resourceIds: ['res-a'],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          },
+          resourceMappings: [
+            {
+              id: 'res-a-model',
+              label: 'My Custom Label',
+              resourceId: 'res-a',
+              resourceType: 'workflow',
+              featureIds: ['ops'],
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'res-a',
+              name: 'Runtime Name Should Not Override',
+              description: 'desc',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['ops'],
+              stepCount: 1,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const node = graph.nodes.find((n) => n.id === 'resource:res-a')
+      expect(node?.label).toBe('My Custom Label')
+    })
+  })
+
+  describe('de-duplication of graph elements', () => {
+    it('creates only one feature node when multiple surfaces reference the same feature', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'crm',
+              label: 'CRM',
+              enabled: true,
+              color: 'blue',
+              entityIds: [],
+              surfaceIds: ['crm.pipeline', 'crm.accounts'],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'crm.pipeline',
+            surfaces: [
+              {
+                id: 'crm.pipeline',
+                label: 'Pipeline',
+                path: '/crm/pipeline',
+                surfaceType: 'graph',
+                featureId: 'crm',
+                featureIds: ['crm'],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              },
+              {
+                id: 'crm.accounts',
+                label: 'Accounts',
+                path: '/crm/accounts',
+                surfaceType: 'list',
+                featureId: 'crm',
+                featureIds: ['crm'],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline', 'crm.accounts'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const featureNodes = graph.nodes.filter((n) => n.id === 'feature:crm')
+      expect(featureNodes).toHaveLength(1)
+    })
+
+    it('creates only one entity node when the same entity appears in both a feature and a surface', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'crm',
+              label: 'CRM',
+              enabled: true,
+              color: 'blue',
+              entityIds: ['crm.deal'],
+              surfaceIds: ['crm.pipeline'],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'crm.pipeline',
+            surfaces: [
+              {
+                id: 'crm.pipeline',
+                label: 'Pipeline',
+                path: '/crm/pipeline',
+                surfaceType: 'graph',
+                featureId: 'crm',
+                featureIds: ['crm'],
+                entityIds: ['crm.deal'],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const entityNodes = graph.nodes.filter((n) => n.id === 'entity:crm.deal')
+      expect(entityNodes).toHaveLength(1)
+    })
+
+    it('creates only one resource node when the same resource appears in resourceMappings and commandViewData', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              enabled: true,
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              resourceIds: ['wf-shared'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: ['ops'],
+                entityIds: [],
+                resourceIds: ['wf-shared'],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          },
+          resourceMappings: [
+            {
+              id: 'wf-shared-model',
+              label: 'Shared Workflow',
+              resourceId: 'wf-shared',
+              resourceType: 'workflow',
+              featureIds: ['ops'],
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'wf-shared',
+              name: 'Shared Workflow Runtime',
+              description: 'desc',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['ops'],
+              stepCount: 1,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:wf-shared')
+      expect(resourceNodes).toHaveLength(1)
+    })
+  })
+
+  describe('commandViewData edge relationships', () => {
+    it('creates a stub resource node with label === resourceId for edges referencing unknown resources', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              enabled: true,
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: [
+            {
+              id: 'edge-unknown',
+              source: 'unknown-source',
+              target: 'unknown-target',
+              relationship: 'triggers'
+            }
+          ]
+        }
+      })
+
+      const sourceNode = graph.nodes.find((n) => n.id === 'resource:unknown-source')
+      expect(sourceNode).toBeDefined()
+      expect(sourceNode?.label).toBe('unknown-source')
+      expect(sourceNode?.sourceId).toBe('unknown-source')
+
+      const targetNode = graph.nodes.find((n) => n.id === 'resource:unknown-target')
+      expect(targetNode).toBeDefined()
+      expect(targetNode?.label).toBe('unknown-target')
+      expect(targetNode?.sourceId).toBe('unknown-target')
+    })
+
+    it('normalizes humanCheckpoints type to human_checkpoint on resource nodes', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              enabled: true,
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [
+            {
+              resourceId: 'approval-step',
+              name: 'Approval Step',
+              description: 'Human review gate',
+              version: '1.0.0',
+              type: 'human',
+              status: 'prod',
+              domains: ['ops']
+            }
+          ],
+          edges: []
+        }
+      })
+
+      const node = graph.nodes.find((n) => n.id === 'resource:approval-step')
+      expect(node).toBeDefined()
+      expect(node?.resourceType).toBe('human_checkpoint')
+    })
+
+    it('creates a references edge with label and relationshipType for commandViewData edges', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          features: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              enabled: true,
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureId: 'operations',
+                featureIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: [
+            {
+              id: 'edge-triggers',
+              source: 'svc-a',
+              target: 'svc-b',
+              relationship: 'triggers'
+            }
+          ]
+        }
+      })
+
+      expect(graph.edges).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            kind: 'references',
+            sourceId: 'resource:svc-a',
+            targetId: 'resource:svc-b',
+            label: 'triggers',
+            relationshipType: 'triggers'
+          })
+        ])
+      )
+    })
+  })
+
+  it('bridges command view topology into resource nodes and labeled relationship edges', () => {
+    const model = resolveOrganizationModel(
+      defineOrganizationModel({
+        features: [
+          {
+            id: 'operations',
+            label: 'Operations',
+            description: 'Operational resources, topology, and orchestration visibility',
+            enabled: true,
+            color: 'violet',
+            entityIds: [],
+            surfaceIds: ['operations.command-view'],
+            resourceIds: ['workflow-order'],
+            capabilityIds: ['operations.command-view']
+          }
+        ],
+        navigation: {
+          defaultSurfaceId: 'operations.command-view',
+          surfaces: [
+            {
+              id: 'operations.command-view',
+              label: 'Command View',
+              path: '/operations/command-view',
+              surfaceType: 'graph',
+              featureId: 'operations',
+              featureIds: ['operations'],
+              entityIds: [],
+              resourceIds: ['workflow-order'],
+              capabilityIds: ['operations.command-view']
+            }
+          ],
+          groups: [
+            {
+              id: 'primary-operations',
+              label: 'Operations',
+              placement: 'primary',
+              surfaceIds: ['operations.command-view']
+            }
+          ]
+        },
+        resourceMappings: [
+          {
+            id: 'workflow-order-model',
+            label: 'Order Workflow Model',
+            resourceId: 'workflow-order',
+            resourceType: 'workflow',
+            featureIds: ['operations'],
+            entityIds: [],
+            surfaceIds: ['operations.command-view'],
+            capabilityIds: []
+          }
+        ]
+      })
+    )
+
+    const graph = buildOrganizationGraph({
+      organizationModel: model,
+      commandViewData: {
+        workflows: [
+          {
+            resourceId: 'workflow-order',
+            name: 'Order Workflow Runtime',
+            description: 'Runtime workflow surfaced by Command View',
+            version: '1.0.0',
+            type: 'workflow',
+            status: 'prod',
+            domains: ['operations'],
+            stepCount: 3,
+            entryPoint: 'start'
+          }
+        ],
+        agents: [
+          {
+            resourceId: 'agent-order',
+            name: 'Order Agent Runtime',
+            description: 'Runtime agent surfaced by Command View',
+            version: '1.0.0',
+            type: 'agent',
+            status: 'prod',
+            domains: ['operations'],
+            modelProvider: 'openai',
+            modelId: 'gpt-4.1',
+            toolCount: 2,
+            hasKnowledgeMap: true,
+            hasMemory: false,
+            sessionCapable: true
+          }
+        ],
+        triggers: [],
+        integrations: [
+          {
+            resourceId: 'integration-stripe',
+            name: 'Stripe Runtime',
+            description: 'Runtime integration surfaced by Command View',
+            version: '1.0.0',
+            type: 'integration',
+            status: 'prod',
+            domains: ['operations'],
+            provider: 'stripe',
+            credentialName: 'stripe-prod'
+          }
+        ],
+        externalResources: [],
+        humanCheckpoints: [
+          {
+            resourceId: 'approval-high-value',
+            name: 'High Value Approval',
+            description: 'Runtime human checkpoint surfaced by Command View',
+            version: '1.0.0',
+            type: 'human',
+            status: 'prod',
+            domains: ['operations']
+          }
+        ],
+        edges: [
+          {
+            id: 'edge-runtime-triggers',
+            source: 'agent-order',
+            target: 'workflow-order',
+            relationship: 'triggers'
+          },
+          {
+            id: 'edge-runtime-uses',
+            source: 'workflow-order',
+            target: 'integration-stripe',
+            relationship: 'uses'
+          },
+          {
+            id: 'edge-runtime-approval',
+            source: 'workflow-order',
+            target: 'approval-high-value',
+            relationship: 'approval'
+          }
+        ]
+      }
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:workflow-order')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'workflow-order',
+      resourceType: 'workflow',
+      label: 'Order Workflow Model'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:agent-order')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'agent-order',
+      resourceType: 'agent',
+      label: 'Order Agent Runtime'
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:approval-high-value')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'approval-high-value',
+      resourceType: 'human_checkpoint',
+      label: 'High Value Approval'
+    })
+
+    expect(graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: 'contains',
+          sourceId: 'organization-model',
+          targetId: 'resource:agent-order'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:agent-order',
+          targetId: 'feature:operations'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:agent-order',
+          targetId: 'resource:workflow-order',
+          label: 'triggers',
+          relationshipType: 'triggers'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:workflow-order',
+          targetId: 'resource:integration-stripe',
+          label: 'uses',
+          relationshipType: 'uses'
+        }),
+        expect.objectContaining({
+          kind: 'references',
+          sourceId: 'resource:workflow-order',
+          targetId: 'resource:approval-high-value',
+          label: 'approval',
+          relationshipType: 'approval'
+        }),
+        expect.objectContaining({
+          kind: 'maps_to',
+          sourceId: 'resource:workflow-order',
+          targetId: 'feature:operations'
+        }),
+        expect.objectContaining({
+          kind: 'maps_to',
+          sourceId: 'resource:workflow-order',
+          targetId: 'surface:operations.command-view'
+        })
+      ])
+    )
+  })
+})