@elevasis/core 0.24.0 → 0.25.0

package/src/organization-model/__tests__/deprecate-helpers.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getSystemDeprecationDependents,
+  type OrganizationModel,
+  type OmTopologyDomain
+} from '../index'
+
+const model = {
+  systems: {
+    sales: {
+      id: 'sales',
+      order: 1,
+      label: 'Sales',
+      lifecycle: 'active',
+      systems: {
+        crm: {
+          id: 'sales.crm',
+          order: 2,
+          label: 'CRM',
+          lifecycle: 'active'
+        }
+      }
+    }
+  },
+  resources: {
+    'crm-active-workflow': {
+      id: 'crm-active-workflow',
+      order: 1,
+      kind: 'workflow',
+      systemPath: 'sales.crm',
+      status: 'active',
+      codeRefs: []
+    },
+    'crm-archived-workflow': {
+      id: 'crm-archived-workflow',
+      order: 2,
+      kind: 'workflow',
+      systemPath: 'sales.crm',
+      status: 'archived',
+      codeRefs: []
+    }
+  },
+  knowledge: {},
+  topology: {
+    version: 1,
+    relationships: {
+      'crm-active-uses-sales': {
+        from: { kind: 'resource', id: 'crm-active-workflow' },
+        kind: 'uses',
+        to: { kind: 'system', id: 'sales' }
+      },
+      'archived-resource-edge': {
+        from: { kind: 'resource', id: 'crm-archived-workflow' },
+        kind: 'uses',
+        to: { kind: 'system', id: 'sales' }
+      }
+    }
+  } satisfies OmTopologyDomain
+} as OrganizationModel
+
+describe('getSystemDeprecationDependents', () => {
+  it('enumerates active resources and topology edges for a system tree', () => {
+    const dependents = getSystemDeprecationDependents(model, 'sales', { includeDescendants: true })
+
+    expect(dependents.resources.map((resource) => resource.id)).toEqual(['crm-active-workflow'])
+    expect(dependents.topologyEdges.map((edge) => edge.id).sort()).toEqual([
+      'archived-resource-edge',
+      'crm-active-uses-sales'
+    ])
+  })
+})

package/src/organization-model/__tests__/domains/resources.test.ts

@@ -31,12 +31,13 @@ const VALID_ROLE = {
 const WORKFLOW_RESOURCE = {
   id: 'LGN-01-company-scrape',
   order: 10,
-  kind: 'workflow' as const,
-  systemPath: 'sys.lead-gen',
-  ownerRoleId: 'role.sales-ops',
-  status: 'active' as const,
-  actionKey: 'lead-gen.company.scrape',
-  codeRefs: [
+  kind: 'workflow' as const,
+  systemPath: 'sys.lead-gen',
+  title: 'Company Scrape',
+  description: 'Scrapes company data for lead generation.',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  codeRefs: [
     {
       path: 'operations/src/lead-gen/company-scrape/index.ts',
       role: 'entrypoint' as const,
@@ -231,7 +232,8 @@ describe('ResourceEntrySchema', () => {
 
   it('accepts optional ontology bindings on resource variants without changing top-level event emissions', () => {
     const ontology = {
-      implements: ['sys.lead-gen:action/company.scrape'],
+      actions: ['sys.lead-gen:action/company.scrape'],
+      primaryAction: 'sys.lead-gen:action/company.scrape',
       reads: ['sys.lead-gen:object/company'],
       writes: ['sys.lead-gen:object/company'],
       usesCatalogs: ['sys.lead-gen:catalog/build-template'],
@@ -268,7 +270,16 @@ describe('ResourceEntrySchema', () => {
   it('rejects malformed ontology binding ids', () => {
     expect(
       ResourceOntologyBindingSchema.safeParse({
-        implements: ['sys.lead-gen/action/company.scrape']
+        actions: ['sys.lead-gen/action/company.scrape']
+      }).success
+    ).toBe(false)
+  })
+
+  it('rejects primaryAction values outside actions', () => {
+    expect(
+      ResourceOntologyBindingSchema.safeParse({
+        actions: ['sys.lead-gen:action/company.scrape'],
+        primaryAction: 'sys.lead-gen:action/company.qualify'
       }).success
     ).toBe(false)
   })

package/src/organization-model/__tests__/domains/topology.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest'
+import { ZodError } from 'zod'
+import {
+  OmTopologyDomainSchema,
+  OmTopologyMetadataSchema,
+  defineTopology,
+  defineTopologyRelationship,
+  parseTopologyNodeRef,
+  topologyRef
+} from '../../domains/topology'
+import { resolveOrganizationModel } from '../../resolve'
+
+const VALID_SYSTEM = {
+  id: 'sales',
+  order: 10,
+  label: 'Sales',
+  enabled: true,
+  lifecycle: 'active' as const
+}
+
+const SOURCE_RESOURCE = {
+  id: 'email-discovery',
+  order: 10,
+  kind: 'workflow' as const,
+  systemPath: 'sales',
+  status: 'active' as const
+}
+
+const TARGET_RESOURCE = {
+  id: 'email-verification',
+  order: 20,
+  kind: 'workflow' as const,
+  systemPath: 'sales',
+  status: 'active' as const
+}
+
+describe('OM topology domain', () => {
+  it('accepts first-class topology relationships', () => {
+    const model = resolveOrganizationModel({
+      systems: { sales: VALID_SYSTEM },
+      resources: {
+        'email-discovery': SOURCE_RESOURCE,
+        'email-verification': TARGET_RESOURCE
+      },
+      topology: {
+        version: 1,
+        relationships: {
+          'email-discovery-triggers-email-verification': {
+            from: { kind: 'resource', id: 'email-discovery' },
+            kind: 'triggers',
+            to: { kind: 'resource', id: 'email-verification' },
+            systemPath: 'sales',
+            required: true,
+            metadata: { source: 'authored' }
+          }
+        }
+      }
+    })
+
+    expect(model.topology.relationships['email-discovery-triggers-email-verification']).toMatchObject({
+      from: { kind: 'resource', id: 'email-discovery' },
+      kind: 'triggers',
+      to: { kind: 'resource', id: 'email-verification' },
+      required: true
+    })
+  })
+
+  it('rejects dangling first-class topology refs', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: { sales: VALID_SYSTEM },
+        resources: { 'email-discovery': SOURCE_RESOURCE },
+        topology: {
+          version: 1,
+          relationships: {
+            'email-discovery-triggers-missing': {
+              from: { kind: 'resource', id: 'email-discovery' },
+              kind: 'triggers',
+              to: { kind: 'resource', id: 'missing-resource' }
+            }
+          }
+        }
+      })
+    ).toThrow(/unknown resource \\"missing-resource\\"/)
+  })
+
+  it('reports dangling topology refs on the relationship side path', () => {
+    let error: unknown
+
+    try {
+      resolveOrganizationModel({
+        systems: { sales: VALID_SYSTEM },
+        resources: { 'email-discovery': SOURCE_RESOURCE },
+        topology: {
+          version: 1,
+          relationships: {
+            'email-discovery-triggers-missing': {
+              from: { kind: 'resource', id: 'email-discovery' },
+              kind: 'triggers',
+              to: { kind: 'resource', id: 'missing-resource' }
+            }
+          }
+        }
+      })
+    } catch (caught) {
+      error = caught
+    }
+
+    expect(error).toBeInstanceOf(ZodError)
+    if (!(error instanceof ZodError)) {
+      throw new Error('Expected resolveOrganizationModel to throw a ZodError')
+    }
+    expect(error.issues).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: ['topology', 'relationships', 'email-discovery-triggers-missing', 'to']
+        })
+      ])
+    )
+  })
+
+  it('rejects secret-like topology metadata', () => {
+    expect(
+      OmTopologyMetadataSchema.safeParse({
+        owner: 'sales-ops',
+        credentials: { apiKey: 'sk-test-12345678901234567890' }
+      }).success
+    ).toBe(false)
+  })
+
+  it('compiles typed resource objects through authoring helpers', () => {
+    const relationship = defineTopologyRelationship({
+      from: SOURCE_RESOURCE,
+      kind: 'uses',
+      to: topologyRef.externalResource('apollo'),
+      required: true
+    })
+
+    expect(relationship).toEqual({
+      from: { kind: 'resource', id: 'email-discovery' },
+      kind: 'uses',
+      to: { kind: 'externalResource', id: 'apollo' },
+      required: true
+    })
+
+    expect(
+      defineTopology({
+        'email-discovery-uses-apollo': {
+          from: SOURCE_RESOURCE,
+          kind: 'uses',
+          to: topologyRef.externalResource('apollo')
+        }
+      })
+    ).toMatchObject({
+      version: 1,
+      relationships: {
+        'email-discovery-uses-apollo': {
+          from: { kind: 'resource', id: 'email-discovery' },
+          to: { kind: 'externalResource', id: 'apollo' }
+        }
+      }
+    })
+  })
+
+  it('parses boundary string refs without making raw strings canonical', () => {
+    expect(parseTopologyNodeRef('resource:email-discovery')).toEqual({
+      kind: 'resource',
+      id: 'email-discovery'
+    })
+    expect(parseTopologyNodeRef('ontology:sales:action/contact.verify-email')).toEqual({
+      kind: 'ontology',
+      id: 'sales:action/contact.verify-email'
+    })
+    expect(() => parseTopologyNodeRef('email-discovery')).toThrow(/must use <kind>:<id>/)
+    expect(() =>
+      OmTopologyDomainSchema.parse({
+        version: 1,
+        relationships: {
+          invalid: {
+            from: 'resource:email-discovery',
+            kind: 'uses',
+            to: { kind: 'resource', id: 'email-verification' }
+          }
+        }
+      })
+    ).toThrow()
+  })
+})

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

@@ -115,15 +115,16 @@ 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('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('implements')).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()
@@ -431,7 +432,8 @@ describe('organization graph', () => {
           systemPath: 'test.bindings',
           status: 'active',
           ontology: {
-            implements: ['test.bindings:action/update-deal'],
+            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'],
@@ -445,7 +447,7 @@ describe('organization graph', () => {
     expect(
       graph.edges.find(
         (edge) =>
-          edge.kind === 'implements' &&
+          edge.kind === 'actions' &&
           edge.sourceId === 'resource:deal-workflow' &&
           edge.targetId === 'ontology:test.bindings:action/update-deal'
       )
@@ -483,8 +485,97 @@ describe('organization graph', () => {
       )
     ).toBeDefined()
   })
-
-  it('projects surface and navigation-group nodes from recursive sidebar leaves', () => {
+
+  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({
       navigation: {
         sidebar: {

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

@@ -31,13 +31,15 @@ describe('organization-model resolve', () => {
     const business = model.navigation.sidebar.primary.business
     expect(business?.type).toBe('group')
     if (business?.type === 'group') {
-      expect(business.children.clients).toMatchObject({
-        type: 'surface',
-        path: '/clients',
-        targets: { systems: ['clients'] }
-      })
-    }
-  })
+      expect(business.children.clients).toMatchObject({
+        type: 'surface',
+        path: '/clients',
+        icon: 'clients',
+        targets: { systems: ['clients'] }
+      })
+    }
+    expect(model.systems.clients?.icon).toBe('clients')
+  })
 
   it('adds tenant systems additively to the merged record', () => {
     const baseSize = Object.keys(resolveOrganizationModel().systems).length

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

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL, scaffoldOrganizationModel, type OrganizationModel } from '..'
+
+const BASE_MODEL: OrganizationModel = {
+  ...DEFAULT_ORGANIZATION_MODEL,
+  systems: {
+    sales: {
+      id: 'sales',
+      order: 10,
+      label: 'Sales',
+      lifecycle: 'active',
+      systems: {
+        crm: {
+          id: 'sales.crm',
+          order: 20,
+          label: 'CRM',
+          lifecycle: 'active'
+        }
+      }
+    }
+  },
+  resources: {},
+  knowledge: {}
+}
+
+describe('organization-model scaffolders', () => {
+  it('plans the minimal system scaffold without route files', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'system',
+      id: 'sales.partners',
+      label: 'Partners',
+      description: 'Partner operations.',
+      noProject: true
+    })
+
+    expect(plan.intent).toBe('system')
+    expect(plan.id).toBe('sales.partners')
+    expect(plan.edits.map((edit) => edit.path)).toEqual(
+      expect.arrayContaining([
+        'packages/elevasis-core/src/organization-model/systems.ts',
+        'packages/elevasis-core/src/organization-model/navigation.ts',
+        'packages/elevasis-core/src/organization-model/roles.ts',
+        'packages/elevasis-core/src/organization-model/assembly.ts',
+        'packages/elevasis-core/src/organization-model/knowledge.ts'
+      ])
+    )
+    expect(plan.writes.some((write) => write.path.endsWith('manifest.stub.ts'))).toBe(true)
+    expect(plan.writes.some((write) => write.path.includes('/routes/'))).toBe(false)
+    expect(plan.projectCommand).toBeUndefined()
+  })
+
+  it('defaults system scaffolds to a project chain unless skipped', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'system',
+      id: 'sales.enablement',
+      label: 'Enablement'
+    })
+
+    expect(plan.projectCommand).toContain('project:create --link-om sales.enablement')
+  })
+
+  it('keeps ontology/resource/knowledge project chains opt-in', () => {
+    const ontology = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'ontology',
+      id: 'deal-score',
+      systemPath: 'sales.crm',
+      kind: 'object'
+    })
+    const resource = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'resource',
+      id: 'crm-score-workflow',
+      systemPath: 'sales.crm'
+    })
+    const knowledge = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'knowledge',
+      id: 'knowledge.crm-scoring',
+      systemPath: 'sales.crm'
+    })
+
+    expect(ontology.projectCommand).toBeUndefined()
+    expect(resource.projectCommand).toBeUndefined()
+    expect(knowledge.projectCommand).toBeUndefined()
+  })
+
+  it('rejects duplicate system paths during planning', () => {
+    expect(() =>
+      scaffoldOrganizationModel(BASE_MODEL, {
+        intent: 'system',
+        id: 'sales.crm'
+      })
+    ).toThrow('system already exists: sales.crm')
+  })
+})

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

@@ -333,9 +333,17 @@ describe('ontology contract validation', () => {
     const compilation = compileOrganizationOntology(model)
 
     expect(compilation.diagnostics).toEqual([])
-    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']?.legacyEntityId).toBe('crm.deal')
+    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']).not.toHaveProperty('legacyEntityId')
+    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']?.origin).toMatchObject({
+      source: 'legacy.entities',
+      legacyId: 'crm.deal'
+    })
     expect(compilation.ontology.actionTypes['dashboard:action/send_reply']?.legacyActionId).toBe('send_reply')
-    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.legacyContentId).toBe('dashboard:pipeline')
+    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']).not.toHaveProperty('legacyContentId')
+    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.origin).toMatchObject({
+      source: 'legacy.system.content',
+      legacyId: 'dashboard:pipeline'
+    })
   })
 
   it('adds origin metadata to authored and projected compiled ontology records without mutating source', () => {
@@ -477,7 +485,8 @@ describe('ontology contract validation', () => {
           systemPath: 'dashboard',
           status: 'active',
           ontology: {
-            implements: ['dashboard:action/process-task'],
+            actions: ['dashboard:action/process-task'],
+            primaryAction: 'dashboard:action/process-task',
             reads: ['dashboard:object/task'],
             writes: ['dashboard:object/task'],
             usesCatalogs: ['dashboard:catalog/task-status'],
@@ -605,7 +614,8 @@ describe('ontology contract validation', () => {
           systemPath: 'dashboard',
           status: 'active',
           ontology: {
-            implements: ['dashboard:action/missing-task'],
+            actions: ['dashboard:action/missing-task'],
+            primaryAction: 'dashboard:action/missing-task',
             reads: ['dashboard:object/missing-task'],
             usesCatalogs: ['dashboard:catalog/missing-status'],
             emits: ['dashboard:event/missing-event']

package/src/organization-model/defaults.ts

@@ -17,6 +17,7 @@ import { DEFAULT_ORGANIZATION_MODEL_OFFERINGS } from './domains/offerings'
 import { DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
 import { DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
+import { DEFAULT_ORGANIZATION_MODEL_TOPOLOGY } from './domains/topology'
 import { CRM_ACTION_ENTRIES, DEFAULT_ORGANIZATION_MODEL_ACTIONS, LEAD_GEN_ACTION_ENTRIES } from './domains/actions'
 import { DEFAULT_ORGANIZATION_MODEL_ENTITIES as DEFAULT_ENTITIES } from './domains/entities'
 import { DEFAULT_ORGANIZATION_MODEL_POLICIES } from './domains/policies'
@@ -45,7 +46,7 @@ const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: OrganizationModelNavigation = {
       business: {
         type: 'group',
         label: 'Business',
-        icon: 'business',
+        icon: 'briefcase',
         order: 20,
         children: {
           sales: {
@@ -62,7 +63,7 @@ const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: OrganizationModelNavigation = {
             label: 'Clients',
             path: '/clients',
             surfaceType: 'list',
-            icon: 'projects',
+            icon: 'clients',
             order: 20,
             targets: { systems: ['clients'] }
           },
@@ -437,7 +438,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       lifecycle: 'active',
       color: 'orange',
-      icon: 'projects',
+      icon: 'clients',
       path: '/clients'
     },
     operations: {
@@ -741,6 +742,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   },
   ontology: DEFAULT_ONTOLOGY_SCOPE,
   resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
   actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
   entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES,
   policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,