@elevasis/core 0.24.0 → 0.25.0

package/src/organization-model/schema.ts

@@ -8,8 +8,9 @@ import { OfferingsDomainSchema, DEFAULT_ORGANIZATION_MODEL_OFFERINGS } from './d
 import { RolesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { GoalsDomainSchema, DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
 import { KnowledgeDomainSchema } from './domains/knowledge'
-import { SystemsDomainSchema, DEFAULT_ORGANIZATION_MODEL_SYSTEMS, type SystemEntry } from './domains/systems'
-import { ResourcesDomainSchema, DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
+import { SystemsDomainSchema, DEFAULT_ORGANIZATION_MODEL_SYSTEMS, type SystemEntry } from './domains/systems'
+import { ResourcesDomainSchema, DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
+import { OmTopologyDomainSchema, DEFAULT_ORGANIZATION_MODEL_TOPOLOGY, type OmTopologyNodeRef } from './domains/topology'
 import { ActionsDomainSchema, DEFAULT_ORGANIZATION_MODEL_ACTIONS } from './domains/actions'
 import { EntitiesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ENTITIES } from './domains/entities'
 import { PoliciesDomainSchema, DEFAULT_ORGANIZATION_MODEL_POLICIES } from './domains/policies'
@@ -33,7 +34,8 @@ export const OrganizationModelDomainKeySchema = z.enum([
   'systems',
   'ontology',
   'resources',
-  'actions',
+  'topology',
+  'actions',
   'entities',
   'policies',
   'knowledge'
@@ -57,7 +59,8 @@ export const DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA: Record<
   systems: { version: 1, lastModified: '2026-05-10' },
   ontology: { version: 1, lastModified: '2026-05-14' },
   resources: { version: 1, lastModified: '2026-05-10' },
-  actions: { version: 1, lastModified: '2026-05-10' },
+  topology: { version: 1, lastModified: '2026-05-14' },
+  actions: { version: 1, lastModified: '2026-05-10' },
   entities: { version: 1, lastModified: '2026-05-10' },
   policies: { version: 1, lastModified: '2026-05-10' },
   knowledge: { version: 1, lastModified: '2026-05-10' }
@@ -74,7 +77,8 @@ export const OrganizationModelDomainMetadataByDomainSchema = z
     systems: OrganizationModelDomainMetadataSchema,
     ontology: OrganizationModelDomainMetadataSchema,
     resources: OrganizationModelDomainMetadataSchema,
-    actions: OrganizationModelDomainMetadataSchema,
+    topology: OrganizationModelDomainMetadataSchema,
+    actions: OrganizationModelDomainMetadataSchema,
     entities: OrganizationModelDomainMetadataSchema,
     policies: OrganizationModelDomainMetadataSchema,
     knowledge: OrganizationModelDomainMetadataSchema
@@ -104,7 +108,8 @@ const OrganizationModelSchemaBase = z.object({
   systems: SystemsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_SYSTEMS),
   ontology: OntologyScopeSchema.default(DEFAULT_ONTOLOGY_SCOPE),
   resources: ResourcesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_RESOURCES),
-  actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
+  topology: OmTopologyDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_TOPOLOGY),
+  actions: ActionsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ACTIONS),
   entities: EntitiesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ENTITIES),
   policies: PoliciesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_POLICIES),
   // D3: flat Record<id, OrgKnowledgeNode> — no wrapper object
@@ -526,6 +531,32 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
   } satisfies Record<OntologyKind, Record<string, unknown>>
   const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index) => Object.keys(index)))
 
+  function topologyTargetExists(ref: OmTopologyNodeRef): boolean {
+    if (ref.kind === 'system') return systemsById.has(ref.id)
+    if (ref.kind === 'resource') return resourcesById.has(ref.id)
+    if (ref.kind === 'ontology') return ontologyIds.has(ref.id)
+    if (ref.kind === 'policy') return policiesById.has(ref.id)
+    if (ref.kind === 'role') return rolesById.has(ref.id)
+
+    // Trigger, human checkpoint, and external resource refs are projected
+    // topology nodes during the bridge period; their owning runtime indexes are
+    // validated by deployment projection in later waves.
+    return true
+  }
+
+  Object.entries(model.topology.relationships).forEach(([relationshipId, relationship]) => {
+    ;(['from', 'to'] as const).forEach((side) => {
+      const ref = relationship[side]
+      if (topologyTargetExists(ref)) return
+
+      addIssue(
+        ctx,
+        ['topology', 'relationships', relationshipId, side],
+        `Topology relationship "${relationshipId}" ${side} references unknown ${ref.kind} "${ref.id}"`
+      )
+    })
+  })
+
   const ontologyReferenceKeyKinds = {
     valueType: 'value-type',
     catalogType: 'catalog',
@@ -694,15 +725,23 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
 
   function validateResourceOntologyBinding(
     resourceId: string,
-    bindingKey: 'implements' | 'reads' | 'writes' | 'usesCatalogs' | 'emits',
+    bindingKey: 'actions' | 'primaryAction' | 'reads' | 'writes' | 'usesCatalogs' | 'emits',
     expectedKind: OntologyKind,
-    ids: string[] | undefined
+    ids: string[] | string | undefined
   ): void {
-    ids?.forEach((ontologyId, ontologyIndex) => {
+    const ontologyIds = ids === undefined ? [] : Array.isArray(ids) ? ids : [ids]
+
+    ontologyIds.forEach((ontologyId, ontologyIndex) => {
       if (ontologyIndexByKind[expectedKind][ontologyId] === undefined) {
         addIssue(
           ctx,
-          ['resources', resourceId, 'ontology', bindingKey, ontologyIndex],
+          [
+            'resources',
+            resourceId,
+            'ontology',
+            bindingKey,
+            ...(Array.isArray(ids) ? [ontologyIndex] : [])
+          ],
           `Resource "${resourceId}" ontology binding "${bindingKey}" references unknown ${expectedKind} ontology ID "${ontologyId}"`
         )
       }
@@ -713,7 +752,8 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     const binding = resource.ontology
     if (binding === undefined) return
 
-    validateResourceOntologyBinding(resource.id, 'implements', 'action', binding.implements)
+    validateResourceOntologyBinding(resource.id, 'actions', 'action', binding.actions)
+    validateResourceOntologyBinding(resource.id, 'primaryAction', 'action', binding.primaryAction)
     validateResourceOntologyBinding(resource.id, 'reads', 'object', binding.reads)
     validateResourceOntologyBinding(resource.id, 'writes', 'object', binding.writes)
     validateResourceOntologyBinding(resource.id, 'usesCatalogs', 'catalog', binding.usesCatalogs)

package/src/organization-model/types.ts

@@ -61,10 +61,18 @@ import {
   ResourceOntologyBindingSchema,
   ResourcesDomainSchema,
   ScriptResourceEntrySchema,
-  ScriptResourceLanguageSchema,
-  ScriptResourceSourceSchema,
-  WorkflowResourceEntrySchema
-} from './domains/resources'
+  ScriptResourceLanguageSchema,
+  ScriptResourceSourceSchema,
+  WorkflowResourceEntrySchema
+} from './domains/resources'
+import {
+  OmTopologyDomainSchema,
+  OmTopologyMetadataSchema,
+  OmTopologyNodeKindSchema,
+  OmTopologyNodeRefSchema,
+  OmTopologyRelationshipKindSchema,
+  OmTopologyRelationshipSchema
+} from './domains/topology'
 import {
   ActionsDomainSchema,
   ActionIdSchema,
@@ -159,13 +167,19 @@ export type OrganizationModelResourceKind = z.infer<typeof ResourceKindSchema>
 export type OrganizationModelResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>
 export type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>
 export type OrganizationModelAgentKind = z.infer<typeof AgentKindSchema>
-export type OrganizationModelScriptResourceLanguage = z.infer<typeof ScriptResourceLanguageSchema>
-export type OrganizationModelScriptResourceSource = z.infer<typeof ScriptResourceSourceSchema>
-export type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
-export type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
-export type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
-export type OrganizationModelScriptResourceEntry = z.infer<typeof ScriptResourceEntrySchema>
-export type OrganizationModelActions = z.infer<typeof ActionsDomainSchema>
+export type OrganizationModelScriptResourceLanguage = z.infer<typeof ScriptResourceLanguageSchema>
+export type OrganizationModelScriptResourceSource = z.infer<typeof ScriptResourceSourceSchema>
+export type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
+export type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
+export type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+export type OrganizationModelScriptResourceEntry = z.infer<typeof ScriptResourceEntrySchema>
+export type OrganizationModelTopology = z.infer<typeof OmTopologyDomainSchema>
+export type OrganizationModelTopologyNodeKind = z.infer<typeof OmTopologyNodeKindSchema>
+export type OrganizationModelTopologyNodeRef = z.infer<typeof OmTopologyNodeRefSchema>
+export type OrganizationModelTopologyRelationshipKind = z.infer<typeof OmTopologyRelationshipKindSchema>
+export type OrganizationModelTopologyRelationship = z.infer<typeof OmTopologyRelationshipSchema>
+export type OrganizationModelTopologyMetadata = z.infer<typeof OmTopologyMetadataSchema>
+export type OrganizationModelActions = z.infer<typeof ActionsDomainSchema>
 export type OrganizationModelAction = z.infer<typeof ActionSchema>
 export type OrganizationModelActionId = z.infer<typeof ActionIdSchema>
 export type OrganizationModelActionScope = z.infer<typeof ActionScopeSchema>

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.9.2'
+  CURRENT: '1.10.2'
 }

package/src/platform/registry/__tests__/validation.test.ts

@@ -304,13 +304,24 @@ describe('validateResourceGovernance', () => {
     order: 20
   }
 
-  const workflowResource: ResourceEntry = {
-    id: 'lead-import',
-    kind: 'workflow',
-    systemPath: 'sys.lead-gen',
-    status: 'active',
-    order: 10
-  }
+  const workflowResource: ResourceEntry = {
+    id: 'lead-import',
+    kind: 'workflow',
+    systemPath: 'sys.lead-gen',
+    status: 'active',
+    order: 10
+  }
+
+  const actionBackedWorkflowResource: ResourceEntry = {
+    ...workflowResource,
+    ontology: {
+      actions: ['sys.lead-gen:action/import-leads'],
+      primaryAction: 'sys.lead-gen:action/import-leads',
+      reads: ['sys.lead-gen:object/company'],
+      usesCatalogs: ['sys.lead-gen:catalog/source'],
+      emits: ['sys.lead-gen:event/imported']
+    }
+  }
 
   const agentResource: ResourceEntry = {
     id: 'lead-import',
@@ -361,10 +372,42 @@ describe('validateResourceGovernance', () => {
     entryPoint: 'start'
   })
 
-  const createModel = (resources: ResourceEntry[] = [workflowResource], systems = [systemA]) => ({
-    systems: Object.fromEntries(systems.map((s) => [s.id, s])),
-    resources: Object.fromEntries(resources.map((r) => [r.id, r]))
-  })
+  const validOntology = {
+    objectTypes: {
+      'sys.lead-gen:object/company': {
+        id: 'sys.lead-gen:object/company',
+        label: 'Company'
+      }
+    },
+    actionTypes: {
+      'sys.lead-gen:action/import-leads': {
+        id: 'sys.lead-gen:action/import-leads',
+        label: 'Import leads'
+      }
+    },
+    catalogTypes: {
+      'sys.lead-gen:catalog/source': {
+        id: 'sys.lead-gen:catalog/source',
+        label: 'Source'
+      }
+    },
+    eventTypes: {
+      'sys.lead-gen:event/imported': {
+        id: 'sys.lead-gen:event/imported',
+        label: 'Imported'
+      }
+    }
+  }
+
+  const createModel = (
+    resources: ResourceEntry[] = [workflowResource],
+    systems = [systemA],
+    extras: Record<string, unknown> = {}
+  ) => ({
+    systems: Object.fromEntries(systems.map((s) => [s.id, s])),
+    resources: Object.fromEntries(resources.map((r) => [r.id, r])),
+    ...extras
+  })
 
   it('passes when code resources are descriptor-backed and match active OM Resources and Systems', () => {
     const result = validateResourceGovernance(
@@ -484,7 +527,7 @@ describe('validateResourceGovernance', () => {
     ).toThrow("Resource 'lead-import' type mismatch: code has 'workflow', OM has 'agent'")
   })
 
-  it('reports descriptor/OM system mismatches', () => {
+  it('reports descriptor/OM system mismatches', () => {
     const codeDescriptor: ResourceEntry = {
       ...workflowResource,
       systemPath: 'sys.crm'
@@ -500,8 +543,150 @@ describe('validateResourceGovernance', () => {
         createModel([workflowResource], [systemA, systemB]),
         { mode: 'strict' }
       )
-    ).toThrow("Resource 'lead-import' system mismatch: code descriptor has 'sys.crm', OM has 'sys.lead-gen'")
-  })
+    ).toThrow("Resource 'lead-import' system mismatch: code descriptor has 'sys.crm', OM has 'sys.lead-gen'")
+  })
+
+  it('reports descriptor/OM ontology mismatches', () => {
+    const codeDescriptor: ResourceEntry = {
+      ...workflowResource,
+      ontology: undefined
+    }
+
+    expect(() =>
+      validateResourceGovernance(
+        'test-org',
+        {
+          version: '1.0.0',
+          workflows: [createGovernedWorkflow(codeDescriptor)]
+        },
+        createModel([actionBackedWorkflowResource], [systemA], { ontology: validOntology }),
+        { mode: 'strict' }
+      )
+    ).toThrow("Resource 'lead-import' ontology descriptor mismatch between code and OM")
+  })
+
+  it('reports missing ontology action refs against compiled OM records', () => {
+    const resourceWithMissingAction: ResourceEntry = {
+      ...workflowResource,
+      ontology: {
+        actions: ['sys.lead-gen:action/missing'],
+        primaryAction: 'sys.lead-gen:action/missing'
+      }
+    }
+
+    expect(() =>
+      validateResourceGovernance(
+        'test-org',
+        {
+          version: '1.0.0',
+          workflows: [createGovernedWorkflow(resourceWithMissingAction)]
+        },
+        createModel([resourceWithMissingAction], [systemA], { ontology: validOntology }),
+        { mode: 'strict' }
+      )
+    ).toThrow(
+      "Resource 'lead-import' ontology.actions references missing action ontology record 'sys.lead-gen:action/missing'"
+    )
+  })
+
+  it('reports new ontology diagnostics without throwing in warn-only mode', () => {
+    const warnings: string[] = []
+    const resourceWithMissingAction: ResourceEntry = {
+      ...workflowResource,
+      ontology: {
+        actions: ['sys.lead-gen:action/missing'],
+        primaryAction: 'sys.lead-gen:action/missing'
+      }
+    }
+
+    const result = validateResourceGovernance(
+      'test-org',
+      {
+        version: '1.0.0',
+        workflows: [createGovernedWorkflow(resourceWithMissingAction)]
+      },
+      createModel([resourceWithMissingAction], [systemA], { ontology: validOntology }),
+      {
+        mode: 'warn-only',
+        onWarning: (issue) => warnings.push(issue.message)
+      }
+    )
+
+    expect(result.valid).toBe(false)
+    expect(result.issues.map((issue) => issue.type)).toContain('ontology-reference-missing')
+    expect(warnings).toContain(
+      "[test-org] Resource 'lead-import' ontology.actions references missing action ontology record 'sys.lead-gen:action/missing'."
+    )
+  })
+
+  it('reports primaryAction values outside ontology.actions', () => {
+    const resourceWithMismatchedPrimaryAction: ResourceEntry = {
+      ...workflowResource,
+      ontology: {
+        actions: ['sys.lead-gen:action/import-leads'],
+        primaryAction: 'sys.lead-gen:action/other'
+      }
+    }
+
+    expect(() =>
+      validateResourceGovernance(
+        'test-org',
+        {
+          version: '1.0.0',
+          workflows: [createGovernedWorkflow(resourceWithMismatchedPrimaryAction)]
+        },
+        createModel([resourceWithMismatchedPrimaryAction], [systemA], { ontology: validOntology }),
+        { mode: 'strict' }
+      )
+    ).toThrow("Resource 'lead-import' primaryAction 'sys.lead-gen:action/other' must be included in ontology.actions")
+  })
+
+  it('reports action-backed workflow descriptors that omit ontology.actions', () => {
+    const resourceWithoutActions: ResourceEntry = {
+      ...workflowResource,
+      ontology: {
+        reads: ['sys.lead-gen:object/company']
+      }
+    }
+
+    expect(() =>
+      validateResourceGovernance(
+        'test-org',
+        {
+          version: '1.0.0',
+          workflows: [createGovernedWorkflow(resourceWithoutActions)]
+        },
+        createModel([resourceWithoutActions], [systemA], { ontology: validOntology }),
+        { mode: 'strict' }
+      )
+    ).toThrow("Resource 'lead-import' declares ontology bindings but no ontology actions")
+  })
+
+  it('reports dangling required topology refs', () => {
+    expect(() =>
+      validateResourceGovernance(
+        'test-org',
+        {
+          version: '1.0.0',
+          workflows: [createGovernedWorkflow()]
+        },
+        createModel([workflowResource], [systemA], {
+          topology: {
+            version: 1,
+            relationships: {
+              'missing-trigger-starts-import': {
+                from: { kind: 'trigger', id: 'missing-trigger' },
+                kind: 'triggers',
+                to: { kind: 'resource', id: 'lead-import' },
+                required: true
+              }
+            }
+          }
+        }),
+        { mode: 'strict' }
+      )
+    ).toThrow("Topology relationship 'missing-trigger-starts-import' from references missing trigger 'missing-trigger'")
+  })
 
   it('reports active OM resources that reference missing Systems', () => {
     const resourceWithMissingSystem: ResourceEntry = {

package/src/platform/registry/resource-registry.ts

@@ -12,10 +12,8 @@
 import type { WorkflowDefinition } from '../../execution/engine/workflow/types'
 import type { AgentDefinition } from '../../execution/engine/agent/core/types'
 import type {
-  OrganizationModel,
-  OrganizationModelResources,
-  OrganizationModelSystems
-} from '../../organization-model/types'
+  OrganizationModel
+} from '../../organization-model/types'
 import type { ResourceEntry } from '../../organization-model/domains/resources'
 import type { SystemEntry } from '../../organization-model/domains/systems'
 import { listAllSystems } from '../../organization-model/helpers'
@@ -106,13 +104,15 @@ export interface SystemConfig {
  * Used by ResourceRegistry for discovery and Command View for visualization.
  */
 export interface DeploymentSpec {
-  /** Deployment version (semver) */
-  version: string
-  /** Optional Organization Model governance catalog used for OM-code validation */
-  organizationModel?: {
-    systems?: OrganizationModelSystems
-    resources?: OrganizationModelResources
-  }
+  /** Deployment version (semver) */
+  version: string
+  /** Optional Organization Model governance catalog used for OM-code validation */
+  organizationModel?: Partial<
+    Pick<
+      OrganizationModel,
+      'systems' | 'resources' | 'ontology' | 'topology' | 'roles' | 'policies' | 'entities' | 'actions'
+    >
+  >
   /** Workflow definitions */
   workflows?: WorkflowDefinition[]
   /** Agent definitions */