@elevasis/core 0.24.1 → 0.26.0

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

@@ -1,14 +1,73 @@
 import { describe, expect, it } from 'vitest'
 import { buildOrganizationGraph } from '../graph/build'
-import { OrganizationGraphEdgeKindSchema, OrganizationGraphNodeKindSchema } from '../graph/schema'
-import { DEFAULT_ORGANIZATION_MODEL_ACTIONS } from '../domains/actions'
-import { DEFAULT_ORGANIZATION_MODEL_ENTITIES } from '../domains/entities'
-import { resolveOrganizationModel } from '../resolve'
-import { resolveSystemConfig } from '../helpers'
+import { OrganizationGraphEdgeKindSchema, OrganizationGraphNodeKindSchema } from '../graph/schema'
+import { resolveOrganizationModel } from '../resolve'
+import { resolveSystemConfig } from '../helpers'
+
+const TEST_ACTION = {
+  id: 'lead-gen.company.source',
+  order: 10,
+  label: 'Source companies',
+  description: 'Import source companies from a list provider.',
+  resourceId: 'lgn-import-workflow',
+  invocations: [{ kind: 'api-endpoint' as const, method: 'POST' as const, path: '/api/prospecting/companies/source' }]
+}
+
+const TEST_SYSTEMS = {
+  sales: {
+    id: 'sales',
+    order: 10,
+    label: 'Sales',
+    lifecycle: 'active' as const,
+    systems: {
+      'lead-gen': {
+        id: 'sales.lead-gen',
+        order: 20,
+        label: 'Lead Gen',
+        lifecycle: 'active' as const,
+        actions: [{ actionId: TEST_ACTION.id, intent: 'exposes' as const }]
+      },
+      crm: {
+        id: 'sales.crm',
+        order: 30,
+        label: 'CRM',
+        lifecycle: 'active' as const
+      }
+    }
+  },
+  operations: {
+    id: 'operations',
+    order: 40,
+    label: 'Operations',
+    lifecycle: 'active' as const
+  }
+}
+
+const TEST_ENTITIES = {
+  'crm.deal': {
+    id: 'crm.deal',
+    order: 10,
+    label: 'Deal',
+    ownedBySystemId: 'sales.crm',
+    links: [{ toEntity: 'crm.contact', kind: 'has-many' as const, label: 'contacts' }]
+  },
+  'crm.contact': {
+    id: 'crm.contact',
+    order: 20,
+    label: 'CRM Contact',
+    ownedBySystemId: 'sales.crm'
+  }
+}
+
+const BASE_GRAPH_MODEL = {
+  systems: TEST_SYSTEMS,
+  actions: { [TEST_ACTION.id]: TEST_ACTION },
+  entities: TEST_ENTITIES
+}
 
 describe('organization graph', () => {
   it('emits system nodes from the systems domain', () => {
-    const graph = buildOrganizationGraph({ organizationModel: resolveOrganizationModel() })
+    const graph = buildOrganizationGraph({ organizationModel: resolveOrganizationModel(BASE_GRAPH_MODEL) })
 
     expect(graph.nodes.find((node) => node.id === 'system:sales.crm')).toMatchObject({
       kind: 'system',
@@ -115,468 +174,431 @@ describe('organization graph', () => {
     expect(() => OrganizationGraphEdgeKindSchema.parse('links')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('affects')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('emits')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('originates_from')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('triggers')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('approval')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('originates_from')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('triggers')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('approval')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('surface')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('customer-segment')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('offering')).not.toThrow()
-    expect(() => OrganizationGraphNodeKindSchema.parse('goal')).not.toThrow()
-    expect(() => OrganizationGraphNodeKindSchema.parse('navigation-group')).not.toThrow()
-    expect(() => OrganizationGraphNodeKindSchema.parse('ontology')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('actions')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('reads')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('writes')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('uses_catalog')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('exposes')).toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse(['operates', 'on'].join('-'))).toThrow()
-  })
-
-  it('projects compiled ontology records as ontology-native nodes and edges', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'test.ontology': {
-          id: 'test.ontology',
-          order: 10,
-          label: 'Ontology System',
-          enabled: true,
-          ontology: {
-            objectTypes: {
-              'test.ontology:object/deal': {
-                id: 'test.ontology:object/deal',
-                label: 'Deal'
-              },
-              'test.ontology:object/contact': {
-                id: 'test.ontology:object/contact',
-                label: 'Contact'
-              }
-            },
-            linkTypes: {
-              'test.ontology:link/deal-contact': {
-                id: 'test.ontology:link/deal-contact',
-                label: 'Deal Contact',
-                from: 'test.ontology:object/deal',
-                to: 'test.ontology:object/contact'
-              }
-            },
-            actionTypes: {
-              'test.ontology:action/update-deal': {
-                id: 'test.ontology:action/update-deal',
-                label: 'Update Deal',
-                actsOn: ['test.ontology:object/deal']
-              }
-            },
-            catalogTypes: {
-              'test.ontology:catalog/pipeline': {
-                id: 'test.ontology:catalog/pipeline',
-                label: 'Pipeline',
-                appliesTo: 'test.ontology:object/deal'
-              }
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(graph.nodes.find((node) => node.id === 'ontology:test.ontology:object/deal')).toMatchObject({
-      kind: 'ontology',
-      sourceId: 'test.ontology:object/deal',
-      label: 'Deal',
-      ontologyKind: 'object'
-    })
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'contains' &&
-          edge.sourceId === 'system:test.ontology' &&
-          edge.targetId === 'ontology:test.ontology:object/deal'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'links' &&
-          edge.sourceId === 'ontology:test.ontology:object/deal' &&
-          edge.targetId === 'ontology:test.ontology:object/contact'
-      )
-    ).toMatchObject({ label: 'Deal Contact' })
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'affects' &&
-          edge.sourceId === 'ontology:test.ontology:action/update-deal' &&
-          edge.targetId === 'ontology:test.ontology:object/deal'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'applies_to' &&
-          edge.sourceId === 'ontology:test.ontology:catalog/pipeline' &&
-          edge.targetId === 'ontology:test.ontology:object/deal'
-      )
-    ).toBeDefined()
-  })
-
-  it('projects ontology-native records from recursively authored systems without content-node bridge input', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        operations: {
-          id: 'operations',
-          order: 10,
-          label: 'Operations',
-          enabled: true,
-          systems: {
-            delivery: {
-              id: 'operations.delivery',
-              order: 20,
-              label: 'Delivery',
-              enabled: true,
-              ontology: {
-                objectTypes: {
-                  'operations.delivery:object/project': {
-                    id: 'operations.delivery:object/project',
-                    label: 'Project'
-                  }
-                },
-                catalogTypes: {
-                  'operations.delivery:catalog/project-status': {
-                    id: 'operations.delivery:catalog/project-status',
-                    label: 'Project Status',
-                    kind: 'status-flow',
-                    appliesTo: 'operations.delivery:object/project'
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(graph.nodes.find((node) => node.id === 'system:operations.delivery')).toMatchObject({
-      kind: 'system',
-      sourceId: 'operations.delivery',
-      label: 'Delivery'
-    })
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'contains' &&
-          edge.sourceId === 'system:operations' &&
-          edge.targetId === 'system:operations.delivery'
-      )
-    ).toBeDefined()
-    expect(graph.nodes.find((node) => node.id === 'ontology:operations.delivery:catalog/project-status')).toMatchObject(
-      {
-        kind: 'ontology',
-        sourceId: 'operations.delivery:catalog/project-status',
-        ontologyKind: 'catalog'
-      }
-    )
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'applies_to' &&
-          edge.sourceId === 'ontology:operations.delivery:catalog/project-status' &&
-          edge.targetId === 'ontology:operations.delivery:object/project'
-      )
-    ).toBeDefined()
-    expect(graph.nodes.some((node) => node.id.startsWith('content-node:operations.delivery:'))).toBe(false)
-  })
-
-  it('keeps subsystems as a compatibility alias for recursive graph traversal', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        legacy: {
-          id: 'legacy',
-          order: 10,
-          label: 'Legacy',
-          enabled: true,
-          subsystems: {
-            child: {
-              id: 'legacy.child',
-              order: 20,
-              label: 'Legacy Child',
-              enabled: true
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(graph.nodes.find((node) => node.id === 'system:legacy.child')).toMatchObject({
-      kind: 'system',
-      sourceId: 'legacy.child',
-      label: 'Legacy Child'
-    })
-  })
-
-  it('resolves first-class system config without requiring config:kv content', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        configurable: {
-          id: 'configurable',
-          order: 10,
-          label: 'Configurable',
-          enabled: true,
-          config: {
-            retries: 3,
-            mode: 'direct',
-            nested: {
-              source: 'system.config',
-              enabled: true
-            }
-          }
-        }
-      }
-    })
-
-    expect(resolveSystemConfig(model, 'configurable')).toEqual({
-      retries: 3,
-      mode: 'direct',
-      nested: {
-        source: 'system.config',
-        enabled: true
-      }
-    })
-    expect(model.systems.configurable?.content).toBeUndefined()
-  })
-
-  it('lets first-class system config override retained config:kv compatibility input', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        configurable: {
-          id: 'configurable',
-          order: 10,
-          label: 'Configurable',
-          enabled: true,
-          config: {
-            retries: 3,
-            nested: {
-              direct: true
-            }
-          },
-          content: {
-            settings: {
-              kind: 'config',
-              type: 'kv',
-              label: 'Settings',
-              data: {
-                entries: {
-                  enabled: true,
-                  retries: 1,
-                  mode: 'bridge'
-                }
-              }
-            }
-          }
-        }
-      }
-    })
-
-    expect(resolveSystemConfig(model, 'configurable')).toEqual({
-      enabled: true,
-      retries: 3,
-      mode: 'bridge',
-      nested: {
-        direct: true
-      }
-    })
-  })
-
-  it('projects resource ontology bindings as resource-to-ontology edges', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'test.bindings': {
-          id: 'test.bindings',
-          order: 10,
-          label: 'Binding System',
-          enabled: true,
-          ontology: {
-            objectTypes: {
-              'test.bindings:object/deal': {
-                id: 'test.bindings:object/deal',
-                label: 'Deal'
-              }
-            },
-            actionTypes: {
-              'test.bindings:action/update-deal': {
-                id: 'test.bindings:action/update-deal',
-                label: 'Update Deal'
-              }
-            },
-            catalogTypes: {
-              'test.bindings:catalog/pipeline': {
-                id: 'test.bindings:catalog/pipeline',
-                label: 'Pipeline'
-              }
-            },
-            eventTypes: {
-              'test.bindings:event/deal-updated': {
-                id: 'test.bindings:event/deal-updated',
-                label: 'Deal Updated'
-              }
-            }
-          }
-        }
-      },
-      resources: {
-        'deal-workflow': {
-          id: 'deal-workflow',
-          order: 10,
-          kind: 'workflow',
-          systemPath: 'test.bindings',
-          status: 'active',
-          ontology: {
-            actions: ['test.bindings:action/update-deal'],
-            primaryAction: 'test.bindings:action/update-deal',
-            reads: ['test.bindings:object/deal'],
-            writes: ['test.bindings:object/deal'],
-            usesCatalogs: ['test.bindings:catalog/pipeline'],
-            emits: ['test.bindings:event/deal-updated']
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'actions' &&
-          edge.sourceId === 'resource:deal-workflow' &&
-          edge.targetId === 'ontology:test.bindings:action/update-deal'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'reads' &&
-          edge.sourceId === 'resource:deal-workflow' &&
-          edge.targetId === 'ontology:test.bindings:object/deal'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'writes' &&
-          edge.sourceId === 'resource:deal-workflow' &&
-          edge.targetId === 'ontology:test.bindings:object/deal'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'uses_catalog' &&
-          edge.sourceId === 'resource:deal-workflow' &&
-          edge.targetId === 'ontology:test.bindings:catalog/pipeline'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'emits' &&
-          edge.sourceId === 'resource:deal-workflow' &&
-          edge.targetId === 'ontology:test.bindings:event/deal-updated'
-      )
-    ).toBeDefined()
-  })
-
-  it('projects topology relationships without collapsing ontology binding edges', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'test.topology': {
-          id: 'test.topology',
-          order: 10,
-          label: 'Topology System',
-          enabled: true,
-          ontology: {
-            actionTypes: {
-              'test.topology:action/discover-email': {
-                id: 'test.topology:action/discover-email',
-                label: 'Discover Email'
-              }
-            }
-          }
-        }
-      },
-      resources: {
-        'email-discovery': {
-          id: 'email-discovery',
-          order: 10,
-          kind: 'workflow',
-          systemPath: 'test.topology',
-          status: 'active',
-          ontology: {
-            actions: ['test.topology:action/discover-email'],
-            primaryAction: 'test.topology:action/discover-email'
-          }
-        },
-        'email-verification': {
-          id: 'email-verification',
-          order: 20,
-          kind: 'workflow',
-          systemPath: 'test.topology',
-          status: 'active'
-        }
-      },
-      topology: {
-        version: 1,
-        relationships: {
-          'email-discovery-triggers-email-verification': {
-            from: { kind: 'resource', id: 'email-discovery' },
-            kind: 'triggers',
-            to: { kind: 'resource', id: 'email-verification' },
-            required: true
-          },
-          'email-verification-approval-human-review': {
-            from: { kind: 'resource', id: 'email-verification' },
-            kind: 'approval',
-            to: { kind: 'humanCheckpoint', id: 'email-review' }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'actions' &&
-          edge.sourceId === 'resource:email-discovery' &&
-          edge.targetId === 'ontology:test.topology:action/discover-email'
-      )
-    ).toBeDefined()
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'triggers' &&
-          edge.relationshipType === 'triggers' &&
-          edge.sourceId === 'resource:email-discovery' &&
-          edge.targetId === 'resource:email-verification'
-      )
-    ).toBeDefined()
-    expect(graph.nodes.find((node) => node.id === 'resource:email-review')).toMatchObject({
-      kind: 'resource',
-      resourceType: 'human_checkpoint'
-    })
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'approval' &&
-          edge.relationshipType === 'approval' &&
-          edge.sourceId === 'resource:email-verification' &&
-          edge.targetId === 'resource:email-review'
-      )
-    ).toBeDefined()
-  })
-
-  it('projects surface and navigation-group nodes from recursive sidebar leaves', () => {
+    expect(() => OrganizationGraphNodeKindSchema.parse('goal')).not.toThrow()
+    expect(() => OrganizationGraphNodeKindSchema.parse('navigation-group')).not.toThrow()
+    expect(() => OrganizationGraphNodeKindSchema.parse('ontology')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('actions')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('reads')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('writes')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('uses_catalog')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('exposes')).toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse(['operates', 'on'].join('-'))).toThrow()
+  })
+
+  it('projects compiled ontology records as ontology-native nodes and edges', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'test.ontology': {
+          id: 'test.ontology',
+          order: 10,
+          label: 'Ontology System',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'test.ontology:object/deal': {
+                id: 'test.ontology:object/deal',
+                label: 'Deal'
+              },
+              'test.ontology:object/contact': {
+                id: 'test.ontology:object/contact',
+                label: 'Contact'
+              }
+            },
+            linkTypes: {
+              'test.ontology:link/deal-contact': {
+                id: 'test.ontology:link/deal-contact',
+                label: 'Deal Contact',
+                from: 'test.ontology:object/deal',
+                to: 'test.ontology:object/contact'
+              }
+            },
+            actionTypes: {
+              'test.ontology:action/update-deal': {
+                id: 'test.ontology:action/update-deal',
+                label: 'Update Deal',
+                actsOn: ['test.ontology:object/deal']
+              }
+            },
+            catalogTypes: {
+              'test.ontology:catalog/pipeline': {
+                id: 'test.ontology:catalog/pipeline',
+                label: 'Pipeline',
+                appliesTo: 'test.ontology:object/deal'
+              }
+            }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.nodes.find((node) => node.id === 'ontology:test.ontology:object/deal')).toMatchObject({
+      kind: 'ontology',
+      sourceId: 'test.ontology:object/deal',
+      label: 'Deal',
+      ontologyKind: 'object'
+    })
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'contains' &&
+          edge.sourceId === 'system:test.ontology' &&
+          edge.targetId === 'ontology:test.ontology:object/deal'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'links' &&
+          edge.sourceId === 'ontology:test.ontology:object/deal' &&
+          edge.targetId === 'ontology:test.ontology:object/contact'
+      )
+    ).toMatchObject({ label: 'Deal Contact' })
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'affects' &&
+          edge.sourceId === 'ontology:test.ontology:action/update-deal' &&
+          edge.targetId === 'ontology:test.ontology:object/deal'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'applies_to' &&
+          edge.sourceId === 'ontology:test.ontology:catalog/pipeline' &&
+          edge.targetId === 'ontology:test.ontology:object/deal'
+      )
+    ).toBeDefined()
+  })
+
+  it('projects ontology-native records from recursively authored systems without content-node bridge input', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        operations: {
+          id: 'operations',
+          order: 10,
+          label: 'Operations',
+          enabled: true,
+          systems: {
+            delivery: {
+              id: 'operations.delivery',
+              order: 20,
+              label: 'Delivery',
+              enabled: true,
+              ontology: {
+                objectTypes: {
+                  'operations.delivery:object/project': {
+                    id: 'operations.delivery:object/project',
+                    label: 'Project'
+                  }
+                },
+                catalogTypes: {
+                  'operations.delivery:catalog/project-status': {
+                    id: 'operations.delivery:catalog/project-status',
+                    label: 'Project Status',
+                    kind: 'status-flow',
+                    appliesTo: 'operations.delivery:object/project'
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.nodes.find((node) => node.id === 'system:operations.delivery')).toMatchObject({
+      kind: 'system',
+      sourceId: 'operations.delivery',
+      label: 'Delivery'
+    })
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'contains' &&
+          edge.sourceId === 'system:operations' &&
+          edge.targetId === 'system:operations.delivery'
+      )
+    ).toBeDefined()
+    expect(graph.nodes.find((node) => node.id === 'ontology:operations.delivery:catalog/project-status')).toMatchObject(
+      {
+        kind: 'ontology',
+        sourceId: 'operations.delivery:catalog/project-status',
+        ontologyKind: 'catalog'
+      }
+    )
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'applies_to' &&
+          edge.sourceId === 'ontology:operations.delivery:catalog/project-status' &&
+          edge.targetId === 'ontology:operations.delivery:object/project'
+      )
+    ).toBeDefined()
+    expect(graph.nodes.some((node) => node.id.startsWith('content-node:operations.delivery:'))).toBe(false)
+  })
+
+  it('keeps subsystems as a compatibility alias for recursive graph traversal', () => {
     const model = resolveOrganizationModel({
+      systems: {
+        legacy: {
+          id: 'legacy',
+          order: 10,
+          label: 'Legacy',
+          enabled: true,
+          subsystems: {
+            child: {
+              id: 'legacy.child',
+              order: 20,
+              label: 'Legacy Child',
+              enabled: true
+            }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(graph.nodes.find((node) => node.id === 'system:legacy.child')).toMatchObject({
+      kind: 'system',
+      sourceId: 'legacy.child',
+      label: 'Legacy Child'
+    })
+  })
+
+  it('resolves first-class system config without requiring config:kv content', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        configurable: {
+          id: 'configurable',
+          order: 10,
+          label: 'Configurable',
+          enabled: true,
+          config: {
+            retries: 3,
+            mode: 'direct',
+            nested: {
+              source: 'system.config',
+              enabled: true
+            }
+          }
+        }
+      }
+    })
+
+    expect(resolveSystemConfig(model, 'configurable')).toEqual({
+      retries: 3,
+      mode: 'direct',
+      nested: {
+        source: 'system.config',
+        enabled: true
+      }
+    })
+    expect(model.systems.configurable?.content).toBeUndefined()
+  })
+
+
+  it('projects resource ontology bindings as resource-to-ontology edges', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'test.bindings': {
+          id: 'test.bindings',
+          order: 10,
+          label: 'Binding System',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'test.bindings:object/deal': {
+                id: 'test.bindings:object/deal',
+                label: 'Deal'
+              }
+            },
+            actionTypes: {
+              'test.bindings:action/update-deal': {
+                id: 'test.bindings:action/update-deal',
+                label: 'Update Deal'
+              }
+            },
+            catalogTypes: {
+              'test.bindings:catalog/pipeline': {
+                id: 'test.bindings:catalog/pipeline',
+                label: 'Pipeline'
+              }
+            },
+            eventTypes: {
+              'test.bindings:event/deal-updated': {
+                id: 'test.bindings:event/deal-updated',
+                label: 'Deal Updated'
+              }
+            }
+          }
+        }
+      },
+      resources: {
+        'deal-workflow': {
+          id: 'deal-workflow',
+          order: 10,
+          kind: 'workflow',
+          systemPath: 'test.bindings',
+          status: 'active',
+          ontology: {
+            actions: ['test.bindings:action/update-deal'],
+            primaryAction: 'test.bindings:action/update-deal',
+            reads: ['test.bindings:object/deal'],
+            writes: ['test.bindings:object/deal'],
+            usesCatalogs: ['test.bindings:catalog/pipeline'],
+            emits: ['test.bindings:event/deal-updated']
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'actions' &&
+          edge.sourceId === 'resource:deal-workflow' &&
+          edge.targetId === 'ontology:test.bindings:action/update-deal'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'reads' &&
+          edge.sourceId === 'resource:deal-workflow' &&
+          edge.targetId === 'ontology:test.bindings:object/deal'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'writes' &&
+          edge.sourceId === 'resource:deal-workflow' &&
+          edge.targetId === 'ontology:test.bindings:object/deal'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'uses_catalog' &&
+          edge.sourceId === 'resource:deal-workflow' &&
+          edge.targetId === 'ontology:test.bindings:catalog/pipeline'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'emits' &&
+          edge.sourceId === 'resource:deal-workflow' &&
+          edge.targetId === 'ontology:test.bindings:event/deal-updated'
+      )
+    ).toBeDefined()
+  })
+
+  it('projects topology relationships without collapsing ontology binding edges', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'test.topology': {
+          id: 'test.topology',
+          order: 10,
+          label: 'Topology System',
+          enabled: true,
+          ontology: {
+            actionTypes: {
+              'test.topology:action/discover-email': {
+                id: 'test.topology:action/discover-email',
+                label: 'Discover Email'
+              }
+            }
+          }
+        }
+      },
+      resources: {
+        'email-discovery': {
+          id: 'email-discovery',
+          order: 10,
+          kind: 'workflow',
+          systemPath: 'test.topology',
+          status: 'active',
+          ontology: {
+            actions: ['test.topology:action/discover-email'],
+            primaryAction: 'test.topology:action/discover-email'
+          }
+        },
+        'email-verification': {
+          id: 'email-verification',
+          order: 20,
+          kind: 'workflow',
+          systemPath: 'test.topology',
+          status: 'active'
+        }
+      },
+      topology: {
+        version: 1,
+        relationships: {
+          'email-discovery-triggers-email-verification': {
+            from: { kind: 'resource', id: 'email-discovery' },
+            kind: 'triggers',
+            to: { kind: 'resource', id: 'email-verification' },
+            required: true
+          },
+          'email-verification-approval-human-review': {
+            from: { kind: 'resource', id: 'email-verification' },
+            kind: 'approval',
+            to: { kind: 'humanCheckpoint', id: 'email-review' }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'actions' &&
+          edge.sourceId === 'resource:email-discovery' &&
+          edge.targetId === 'ontology:test.topology:action/discover-email'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'triggers' &&
+          edge.relationshipType === 'triggers' &&
+          edge.sourceId === 'resource:email-discovery' &&
+          edge.targetId === 'resource:email-verification'
+      )
+    ).toBeDefined()
+    expect(graph.nodes.find((node) => node.id === 'resource:email-review')).toMatchObject({
+      kind: 'resource',
+      resourceType: 'human_checkpoint'
+    })
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'approval' &&
+          edge.relationshipType === 'approval' &&
+          edge.sourceId === 'resource:email-verification' &&
+          edge.targetId === 'resource:email-review'
+      )
+    ).toBeDefined()
+  })
+
+  it('projects surface and navigation-group nodes from recursive sidebar leaves', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        sales: TEST_SYSTEMS.sales
+      },
+      actions: { [TEST_ACTION.id]: TEST_ACTION },
       navigation: {
         sidebar: {
           primary: {
@@ -699,8 +721,48 @@ describe('organization graph', () => {
     })
   })
 
-  // Wave 5: content-node graph projection — one node per system.content entry.
-  it('projects content-node graph nodes from system content entries', () => {
+
+  it('projects action nodes from the actions domain with maps_to edges to resources', () => {
+    const action = TEST_ACTION
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        systems: TEST_SYSTEMS,
+        actions: { [action.id]: action },
+        resources: {
+          [action.resourceId]: {
+            id: action.resourceId,
+            order: 10,
+            kind: 'workflow',
+            systemPath: 'sales.lead-gen',
+            status: 'active'
+          }
+        }
+      })
+    })
+
+    const actionNodes = graph.nodes.filter((node) => node.kind === 'action')
+    expect(actionNodes).toHaveLength(1)
+
+    const node = graph.nodes.find((n) => n.id === `action:${action.id}`)
+    expect(node).toMatchObject({
+      kind: 'action',
+      sourceId: action.id,
+      label: action.label,
+      description: action.description
+    })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'maps_to' &&
+          edge.sourceId === `action:${action.id}` &&
+          edge.targetId === `resource:${action.resourceId}`
+      )
+    ).toBeDefined()
+
+    expect(graph.nodes.find((n) => n.id === `resource:${action.resourceId}`)).toBeDefined()
+  })
+  it('projects ontology catalog nodes without content-node bridge output', () => {
     const model = resolveOrganizationModel({
       systems: {
         'test.pipeline-sys': {
@@ -708,19 +770,24 @@ describe('organization graph', () => {
           order: 10,
           label: 'Pipeline System',
           enabled: true,
-          content: {
-            'deal-pipeline': {
-              kind: 'schema',
-              type: 'pipeline',
-              label: 'Deal Pipeline',
-              data: { entityId: 'crm.deal' }
+          ontology: {
+            objectTypes: {
+              'test.pipeline-sys:object/deal': {
+                id: 'test.pipeline-sys:object/deal',
+                label: 'Deal',
+                ownerSystemId: 'test.pipeline-sys'
+              }
             },
-            'closed-won': {
-              kind: 'schema',
-              type: 'stage',
-              label: 'Closed Won',
-              parentContentId: 'deal-pipeline',
-              data: { semanticClass: 'closed_won' }
+            catalogTypes: {
+              'test.pipeline-sys:catalog/deal-pipeline': {
+                id: 'test.pipeline-sys:catalog/deal-pipeline',
+                label: 'Deal Pipeline',
+                kind: 'pipeline',
+                appliesTo: 'test.pipeline-sys:object/deal',
+                entries: {
+                  'closed-won': { label: 'Closed Won', order: 10, semanticClass: 'closed_won' }
+                }
+              }
             }
           }
         }
@@ -728,77 +795,124 @@ describe('organization graph', () => {
     })
     const graph = buildOrganizationGraph({ organizationModel: model })
 
-    // Pipeline content-node emitted
-    expect(graph.nodes.find((n) => n.id === 'content-node:test.pipeline-sys:deal-pipeline')).toMatchObject({
-      kind: 'content-node',
-      sourceId: 'test.pipeline-sys:deal-pipeline',
-      label: 'Deal Pipeline'
+    expect(graph.nodes.find((n) => n.id === 'ontology:test.pipeline-sys:catalog/deal-pipeline')).toMatchObject({
+      kind: 'ontology',
+      sourceId: 'test.pipeline-sys:catalog/deal-pipeline',
+      label: 'Deal Pipeline',
+      ontologyKind: 'catalog'
     })
-
-    // Stage content-node emitted
-    expect(graph.nodes.find((n) => n.id === 'content-node:test.pipeline-sys:closed-won')).toMatchObject({
-      kind: 'content-node',
-      sourceId: 'test.pipeline-sys:closed-won',
-      label: 'Closed Won'
-    })
-
-    // contains: system spine → pipeline content-node
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'system:test.pipeline-sys' &&
-          e.targetId === 'content-node:test.pipeline-sys:deal-pipeline'
-      )
-    ).toBeDefined()
-
-    // contains: system spine → stage content-node
+    expect(graph.nodes.some((n) => n.id.startsWith('content-node:'))).toBe(false)
     expect(
       graph.edges.find(
         (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'system:test.pipeline-sys' &&
-          e.targetId === 'content-node:test.pipeline-sys:closed-won'
+          e.kind === 'applies_to' &&
+          e.sourceId === 'ontology:test.pipeline-sys:catalog/deal-pipeline' &&
+          e.targetId === 'ontology:test.pipeline-sys:object/deal'
       )
     ).toBeDefined()
   })
 
-  it('projects action nodes from the actions domain with maps_to edges to resources', () => {
-    const graph = buildOrganizationGraph({
-      organizationModel: resolveOrganizationModel()
+  it('projects status-flow catalog entries through ontology rather than content parent chains', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'test.status-sys': {
+          id: 'test.status-sys',
+          order: 10,
+          label: 'Status System',
+          enabled: true,
+          ontology: {
+            objectTypes: {
+              'test.status-sys:object/task': {
+                id: 'test.status-sys:object/task',
+                label: 'Task',
+                ownerSystemId: 'test.status-sys'
+              }
+            },
+            catalogTypes: {
+              'test.status-sys:catalog/task-status-flow': {
+                id: 'test.status-sys:catalog/task-status-flow',
+                label: 'Task Status Flow',
+                kind: 'status-flow',
+                appliesTo: 'test.status-sys:object/task',
+                entries: {
+                  approved: { label: 'Approved', order: 10 },
+                  rejected: { label: 'Rejected', order: 20 }
+                }
+              }
+            }
+          }
+        }
+      }
     })
+    const graph = buildOrganizationGraph({ organizationModel: model })
 
-    const actionNodes = graph.nodes.filter((node) => node.kind === 'action')
-    expect(actionNodes).toHaveLength(Object.keys(DEFAULT_ORGANIZATION_MODEL_ACTIONS).length)
-
-    const sample = Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS)[0]!
-    const node = graph.nodes.find((n) => n.id === `action:${sample.id}`)
-    expect(node).toMatchObject({
-      kind: 'action',
-      sourceId: sample.id,
-      label: sample.label,
-      description: sample.description
+    expect(graph.nodes.find((n) => n.id === 'ontology:test.status-sys:catalog/task-status-flow')).toMatchObject({
+      kind: 'ontology',
+      label: 'Task Status Flow'
     })
+    expect(graph.nodes.some((n) => n.id.startsWith('content-node:test.status-sys:'))).toBe(false)
+  })
 
-    expect(
-      graph.edges.find(
-        (edge) =>
-          edge.kind === 'maps_to' &&
-          edge.sourceId === `action:${sample.id}` &&
-          edge.targetId === `resource:${sample.resourceId}`
-      )
-    ).toBeDefined()
+  it('projects nested system ontology catalogs with scoped ontology node ids', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        ops: {
+          id: 'ops',
+          order: 10,
+          label: 'Ops',
+          enabled: true,
+          systems: {
+            delivery: {
+              id: 'ops.delivery',
+              order: 20,
+              label: 'Delivery',
+              enabled: true,
+              ontology: {
+                objectTypes: {
+                  'ops.delivery:object/list': {
+                    id: 'ops.delivery:object/list',
+                    label: 'List',
+                    ownerSystemId: 'ops.delivery'
+                  }
+                },
+                catalogTypes: {
+                  'ops.delivery:catalog/onboarding-template': {
+                    id: 'ops.delivery:catalog/onboarding-template',
+                    label: 'Onboarding Template',
+                    kind: 'template',
+                    appliesTo: 'ops.delivery:object/list',
+                    entries: {
+                      default: { label: 'Default' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
 
-    expect(graph.nodes.find((n) => n.id === `resource:${sample.resourceId}`)).toBeDefined()
+    expect(graph.nodes.find((n) => n.id === 'ontology:ops.delivery:catalog/onboarding-template')).toMatchObject({
+      kind: 'ontology',
+      sourceId: 'ops.delivery:catalog/onboarding-template',
+      label: 'Onboarding Template'
+    })
+    expect(graph.nodes.some((n) => n.id.startsWith('content-node:ops.delivery:'))).toBe(false)
   })
 
   it('projects entity nodes with system contains edges and entity links', () => {
     const graph = buildOrganizationGraph({
-      organizationModel: resolveOrganizationModel()
+      organizationModel: resolveOrganizationModel({
+        systems: TEST_SYSTEMS,
+        actions: { [TEST_ACTION.id]: TEST_ACTION },
+        entities: TEST_ENTITIES
+      })
     })
 
     const entityNodes = graph.nodes.filter((node) => node.kind === 'entity')
-    expect(entityNodes).toHaveLength(Object.keys(DEFAULT_ORGANIZATION_MODEL_ENTITIES).length)
+    expect(entityNodes).toHaveLength(Object.keys(TEST_ENTITIES).length)
     expect(graph.nodes.find((node) => node.id === 'entity:crm.deal')).toMatchObject({
       kind: 'entity',
       sourceId: 'crm.deal',
@@ -819,7 +933,10 @@ describe('organization graph', () => {
 
   it('projects affects edges from actions to entities', () => {
     const model = resolveOrganizationModel({
+      systems: TEST_SYSTEMS,
+      entities: TEST_ENTITIES,
       actions: {
+        [TEST_ACTION.id]: TEST_ACTION,
         'crm.deal.update': {
           id: 'crm.deal.update',
           order: 10,
@@ -840,6 +957,8 @@ describe('organization graph', () => {
 
   it('projects event nodes from workflow and agent resource emission traits', () => {
     const model = resolveOrganizationModel({
+      systems: TEST_SYSTEMS,
+      actions: { [TEST_ACTION.id]: TEST_ACTION },
       resources: {
         'leadgen-reply-workflow': {
           id: 'leadgen-reply-workflow',
@@ -892,79 +1011,11 @@ describe('organization graph', () => {
     expect(graph.nodes.some((node) => node.id.startsWith('event:crm-integration:'))).toBe(false)
   })
 
-  // Wave 5: content-node parentContentId chain emits contains edges parent → child.
-  it('emits contains edges for parentContentId chains between content-nodes', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'test.status-sys': {
-          id: 'test.status-sys',
-          order: 10,
-          label: 'Status System',
-          enabled: true,
-          content: {
-            'task-status-flow': {
-              kind: 'schema',
-              type: 'status-flow',
-              label: 'Task Status Flow'
-            },
-            'status-approved': {
-              kind: 'schema',
-              type: 'status',
-              label: 'Approved',
-              parentContentId: 'task-status-flow'
-            },
-            'status-rejected': {
-              kind: 'schema',
-              type: 'status',
-              label: 'Rejected',
-              parentContentId: 'task-status-flow'
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    // Parent content-node emitted
-    expect(graph.nodes.find((n) => n.id === 'content-node:test.status-sys:task-status-flow')).toMatchObject({
-      kind: 'content-node',
-      label: 'Task Status Flow'
-    })
-
-    // Child content-nodes emitted
-    expect(graph.nodes.find((n) => n.id === 'content-node:test.status-sys:status-approved')).toMatchObject({
-      kind: 'content-node',
-      label: 'Approved'
-    })
-    expect(graph.nodes.find((n) => n.id === 'content-node:test.status-sys:status-rejected')).toMatchObject({
-      kind: 'content-node',
-      label: 'Rejected'
-    })
-
-    // parentContentId chain: parent → approved
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'content-node:test.status-sys:task-status-flow' &&
-          e.targetId === 'content-node:test.status-sys:status-approved'
-      )
-    ).toBeDefined()
-
-    // parentContentId chain: parent → rejected
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'content-node:test.status-sys:task-status-flow' &&
-          e.targetId === 'content-node:test.status-sys:status-rejected'
-      )
-    ).toBeDefined()
-  })
 
   it('links event-triggered policies to projected event nodes', () => {
-    const action = Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS)[0]!
+    const action = TEST_ACTION
     const model = resolveOrganizationModel({
+      ...BASE_GRAPH_MODEL,
       resources: {
         'leadgen-reply-workflow': {
           id: 'leadgen-reply-workflow',
@@ -1008,7 +1059,7 @@ describe('organization graph', () => {
   })
 
   it('emits uses edges from systems to attached actions', () => {
-    const graph = buildOrganizationGraph({ organizationModel: resolveOrganizationModel() })
+    const graph = buildOrganizationGraph({ organizationModel: resolveOrganizationModel(BASE_GRAPH_MODEL) })
 
     expect(
       graph.edges.find(
@@ -1021,8 +1072,9 @@ describe('organization graph', () => {
   })
 
   it('derives resource membership and agent invocation edges from canonical OM fields', () => {
-    const action = Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS)[0]!
+    const action = TEST_ACTION
     const model = resolveOrganizationModel({
+      ...BASE_GRAPH_MODEL,
       resources: {
         'ops-agent': {
           id: 'ops-agent',
@@ -1075,104 +1127,13 @@ describe('organization graph', () => {
     ).toMatchObject({ label: 'script ops-script' })
   })
 
-  // Wave 5: pipeline content-node with data.entityId emits a references edge to the entity node.
-  it('emits references edges from pipeline content-nodes to their target entity nodes', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'test.pipeline-ref': {
-          id: 'test.pipeline-ref',
-          order: 10,
-          label: 'Pipeline Ref System',
-          enabled: true,
-          content: {
-            'deal-pipeline': {
-              kind: 'schema',
-              type: 'pipeline',
-              label: 'Deal Pipeline',
-              data: { entityId: 'crm.deal' }
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    // references: pipeline content-node → entity node
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'references' &&
-          e.sourceId === 'content-node:test.pipeline-ref:deal-pipeline' &&
-          e.targetId === 'entity:crm.deal'
-      )
-    ).toMatchObject({ label: 'applies to entity' })
-  })
-
-  // Wave 5: content-nodes across nested subsystems are projected correctly.
-  it('projects content-nodes from nested subsystem paths with correct scoped node ids', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        'ops.delivery': {
-          id: 'ops.delivery',
-          order: 10,
-          label: 'Delivery',
-          enabled: true,
-          content: {
-            'template-onboard': {
-              kind: 'schema',
-              type: 'template',
-              label: 'Onboarding Template'
-            },
-            'step-intro': {
-              kind: 'schema',
-              type: 'template-step',
-              label: 'Introduction Step',
-              parentContentId: 'template-onboard'
-            }
-          }
-        }
-      }
-    })
-    const graph = buildOrganizationGraph({ organizationModel: model })
-
-    // Node ids use full dot-separated system path
-    expect(graph.nodes.find((n) => n.id === 'content-node:ops.delivery:template-onboard')).toMatchObject({
-      kind: 'content-node',
-      sourceId: 'ops.delivery:template-onboard',
-      label: 'Onboarding Template'
-    })
-    expect(graph.nodes.find((n) => n.id === 'content-node:ops.delivery:step-intro')).toMatchObject({
-      kind: 'content-node',
-      sourceId: 'ops.delivery:step-intro',
-      label: 'Introduction Step'
-    })
-
-    // contains: system spine (ops.delivery) → template content-node
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'system:ops.delivery' &&
-          e.targetId === 'content-node:ops.delivery:template-onboard'
-      )
-    ).toBeDefined()
-
-    // parentContentId chain: template → step
-    expect(
-      graph.edges.find(
-        (e) =>
-          e.kind === 'contains' &&
-          e.sourceId === 'content-node:ops.delivery:template-onboard' &&
-          e.targetId === 'content-node:ops.delivery:step-intro'
-      )
-    ).toBeDefined()
-  })
 
   describe('policy edges in graph projection', () => {
-    const action = Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS)[0]!
+    const action = TEST_ACTION
 
     it('event-triggered policy emits triggers edge from event node to policy node', () => {
       const model = resolveOrganizationModel({
+        ...BASE_GRAPH_MODEL,
         resources: {
           'reply-workflow': {
             id: 'reply-workflow',
@@ -1207,6 +1168,7 @@ describe('organization graph', () => {
 
     it('action-invocation-triggered policy emits triggers edge from action node to policy node', () => {
       const model = resolveOrganizationModel({
+        ...BASE_GRAPH_MODEL,
         policies: {
           'policy.action.gate': {
             id: 'policy.action.gate',
@@ -1231,6 +1193,7 @@ describe('organization graph', () => {
 
     it('invoke-action effect emits effects edge from policy to target action', () => {
       const model = resolveOrganizationModel({
+        ...BASE_GRAPH_MODEL,
         policies: {
           'policy.invoke': {
             id: 'policy.invoke',
@@ -1319,6 +1282,8 @@ describe('organization graph', () => {
 
     it('appliesTo.systemIds emits applies_to edges to each system', () => {
       const model = resolveOrganizationModel({
+        systems: TEST_SYSTEMS,
+        actions: { [TEST_ACTION.id]: TEST_ACTION },
         policies: {
           'policy.sys-scope': {
             id: 'policy.sys-scope',
@@ -1352,6 +1317,7 @@ describe('organization graph', () => {
 
     it('appliesTo.actionIds emits applies_to edges to each action', () => {
       const model = resolveOrganizationModel({
+        ...BASE_GRAPH_MODEL,
         policies: {
           'policy.action-scope': {
             id: 'policy.action-scope',
@@ -1377,6 +1343,8 @@ describe('organization graph', () => {
 
     it('appliesTo.resourceIds emits applies_to edges to each resource', () => {
       const model = resolveOrganizationModel({
+        systems: TEST_SYSTEMS,
+        actions: { [TEST_ACTION.id]: TEST_ACTION },
         resources: {
           'scoped-workflow': {
             id: 'scoped-workflow',