@elevasis/core 0.10.0 → 0.11.1

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

@@ -1,894 +1,82 @@
-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/build'
+import { resolveOrganizationModel } from '../resolve'
+
+describe('organization graph', () => {
+  it('emits feature nodes from the flat features array', () => {
+    const graph = buildOrganizationGraph({ organizationModel: resolveOrganizationModel() })
+
+    expect(graph.nodes.find((node) => node.id === 'feature:sales.crm')).toMatchObject({
+      kind: 'feature',
+      sourceId: 'sales.crm',
+      label: 'CRM'
+    })
+    expect(graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')).toMatchObject({
+      kind: 'contains'
+    })
+  })
+
+  it('uses overridden feature labels', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'custom', label: 'Custom Workspace', enabled: true, path: '/custom' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.nodes.find((node) => node.id === 'feature:custom')?.label).toBe('Custom Workspace')
+  })
+
+  it('bridges command view resources and relationships', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({
+      organizationModel: model,
+      commandViewData: {
+        generatedAt: '2026-04-24T00:00:00.000Z',
+        workflows: [
+          {
+            resourceId: 'workflow-order',
+            name: 'Order Workflow',
+            description: 'Order workflow',
+            type: 'workflow',
+            links: [],
+            status: 'active'
+          }
+        ],
+        agents: [],
+        triggers: [],
+        integrations: [],
+        externalResources: [],
+        humanCheckpoints: [],
+        edges: [
+          {
+            id: 'edge-1',
+            source: 'workflow-order',
+            target: 'missing-resource',
+            relationship: 'uses'
+          }
+        ],
+        stats: {
+          totalResources: 1,
+          activeResources: 1,
+          inactiveResources: 0,
+          resourcesByType: {}
+        }
+      }
+    })
+
+    expect(graph.nodes.find((node) => node.id === 'resource:workflow-order')).toMatchObject({
+      kind: 'resource',
+      sourceId: 'workflow-order',
+      label: 'Order Workflow'
+    })
+    expect(graph.nodes.find((node) => node.id === 'resource:missing-resource')).toMatchObject({
+      kind: 'resource',
+      label: 'missing-resource'
+    })
+    expect(graph.edges.find((edge) => edge.id.includes('uses'))).toMatchObject({
+      kind: 'references',
+      relationshipType: 'uses'
+    })
+  })
+})