@elevasis/core 0.22.0 → 0.23.0

package/src/platform/registry/__tests__/resource-registry.integration.test.ts

@@ -32,19 +32,14 @@ describe('ResourceRegistry Integration', () => {
   // Mock Data Helpers
   // ============================================================================
 
-  const createMockWorkflow = (
-    resourceId: string,
-    status: 'dev' | 'prod' = 'dev',
-    links?: Array<{ nodeId: string; kind: 'operates-on' }>
-  ): WorkflowDefinition => ({
+  const createMockWorkflow = (resourceId: string, status: 'dev' | 'prod' = 'dev'): WorkflowDefinition => ({
     config: {
       resourceId,
       name: `Workflow ${resourceId}`,
       description: `Test workflow ${resourceId}`,
       version: '1.0.0',
       type: 'workflow',
-      status,
-      links
+      status
     },
     contract: {
       inputSchema: z.object({ data: z.string() }),
@@ -64,11 +59,7 @@ describe('ResourceRegistry Integration', () => {
     entryPoint: 'step1'
   })
 
-  const createMockAgent = (
-    resourceId: string,
-    status: 'dev' | 'prod' = 'dev',
-    links?: Array<{ nodeId: string; kind: 'operates-on' }>
-  ): AgentDefinition => ({
+  const createMockAgent = (resourceId: string, status: 'dev' | 'prod' = 'dev'): AgentDefinition => ({
     config: {
       resourceId,
       name: `Agent ${resourceId}`,
@@ -76,8 +67,7 @@ describe('ResourceRegistry Integration', () => {
       version: '1.0.0',
       type: 'agent',
       status,
-      systemPrompt: 'You are a test agent',
-      links
+      systemPrompt: 'You are a test agent'
     },
     contract: {
       inputSchema: z.object({ query: z.string() }),
@@ -97,13 +87,13 @@ describe('ResourceRegistry Integration', () => {
    */
   const createTestOrganization = (): DeploymentSpec => {
     const workflows = [
-      createMockWorkflow('order-workflow', 'prod', ['sales']),
-      createMockWorkflow('support-workflow', 'dev', ['support'])
+      createMockWorkflow('order-workflow', 'prod'),
+      createMockWorkflow('support-workflow', 'dev')
     ]
 
     const agents = [
-      createMockAgent('order-agent', 'prod', ['sales']),
-      createMockAgent('support-agent', 'dev', ['support'])
+      createMockAgent('order-agent', 'prod'),
+      createMockAgent('support-agent', 'dev')
     ]
 
     const triggers: TriggerDefinition[] = [
@@ -115,8 +105,7 @@ describe('ResourceRegistry Integration', () => {
         name: 'Order Webhook',
         description: 'Webhook from Shopify on new orders',
         status: 'prod',
-        webhookPath: '/webhooks/shopify/orders',
-        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
+        webhookPath: '/webhooks/shopify/orders'
       },
       {
         resourceId: 'trigger-schedule-support',
@@ -125,9 +114,8 @@ describe('ResourceRegistry Integration', () => {
         version: '1.0.0',
         name: 'Support Ticket Check',
         description: 'Check for new support tickets every hour',
-        status: 'dev',
-        schedule: '0 * * * *',
-        links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
+        status: 'dev',
+        schedule: '0 * * * *'
       },
       {
         resourceId: 'trigger-manual-test',
@@ -148,9 +136,8 @@ describe('ResourceRegistry Integration', () => {
         status: 'prod',
         provider: 'shopify',
         credentialName: 'shopify-prod',
-        name: 'Shopify Production',
-        description: 'E-commerce platform',
-        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
+        name: 'Shopify Production',
+        description: 'E-commerce platform'
       },
       {
         resourceId: 'integration-zendesk',
@@ -159,9 +146,8 @@ describe('ResourceRegistry Integration', () => {
         status: 'dev',
         provider: 'zendesk',
         credentialName: 'zendesk-dev',
-        name: 'Zendesk Support',
-        description: 'Support ticket system',
-        links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
+        name: 'Zendesk Support',
+        description: 'Support ticket system'
       }
     ]
 
@@ -201,8 +187,7 @@ describe('ResourceRegistry Integration', () => {
         description: 'Approve orders over $10,000',
         status: 'prod',
         requestedBy: { agents: ['order-agent'] },
-        routesTo: { workflows: ['order-workflow'] },
-        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
+        routesTo: { workflows: ['order-workflow'] }
       },
       {
         resourceId: 'approval-escalation',

package/src/platform/registry/__tests__/resource-registry.nested-systems.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Regression tests for resource-registry nested-systems lookup (Wave 1 hotfix).
+ *
+ * Before the fix, `listResourcesForOrganization` built the systems map with
+ * `Object.values(org.systems)`, which only surfaced top-level entries. Systems
+ * declared as children under `system.subsystems` were invisible, so
+ * `summarizeSystem` always returned `undefined` for nested paths.
+ *
+ * After the fix, the map is built via `listAllSystems` (DFS), which walks the
+ * full tree and keys every entry by its dot-joined path.
+ */
+import { describe, it, expect } from 'vitest'
+import { z } from 'zod'
+import { ResourceRegistry } from '../resource-registry'
+import type { SystemEntry } from '../../../organization-model/domains/systems'
+import type { ResourceEntry } from '../../../organization-model/domains/resources'
+import type { WorkflowDefinition } from '../../../execution/engine/workflow/types'
+
+// ---------------------------------------------------------------------------
+// Minimal fixture helpers
+// ---------------------------------------------------------------------------
+
+function makeWorkflow(resourceId: string, resource?: ResourceEntry): WorkflowDefinition {
+  return {
+    config: {
+      resourceId,
+      name: `Workflow ${resourceId}`,
+      description: `Test workflow ${resourceId}`,
+      version: '1.0.0',
+      type: 'workflow',
+      status: 'prod',
+      resource
+    },
+    contract: {
+      inputSchema: z.object({ input: z.string() }),
+      outputSchema: z.object({ output: z.string() })
+    },
+    steps: {
+      step1: {
+        id: 'step1',
+        name: 'Step 1',
+        description: 'Only step',
+        handler: async () => ({ output: 'ok' }),
+        inputSchema: z.object({ input: z.string() }),
+        outputSchema: z.object({ output: z.string() }),
+        next: null
+      }
+    },
+    entryPoint: 'step1'
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fixture: two-level system tree
+//
+//   systems
+//   └── acquisition          (top-level, id: 'acquisition')
+//       └── subsystems
+//           └── outbound     (nested, id: 'outbound')  ← formerly invisible
+// ---------------------------------------------------------------------------
+
+const topLevelSystem: SystemEntry = {
+  id: 'acquisition',
+  label: 'Acquisition',
+  description: 'Top-level acquisition system.',
+  kind: 'operational',
+  governedByKnowledge: [],
+  drivesGoals: [],
+  lifecycle: 'active',
+  order: 10
+}
+
+const nestedSystem: SystemEntry = {
+  id: 'outbound',
+  label: 'Outbound',
+  description: 'Outbound automation sub-system.',
+  kind: 'operational',
+  governedByKnowledge: [],
+  drivesGoals: [],
+  lifecycle: 'active',
+  order: 10
+}
+
+/** Dot-joined path for the nested system as it appears in resource.systemPath */
+const NESTED_SYSTEM_PATH = 'acquisition.outbound'
+
+const topLevelSystemWithChildren: SystemEntry = {
+  ...topLevelSystem,
+  subsystems: {
+    outbound: nestedSystem
+  }
+}
+
+const nestedSystemResource: ResourceEntry = {
+  id: 'cold-outreach-workflow',
+  kind: 'workflow',
+  systemPath: NESTED_SYSTEM_PATH,
+  status: 'active',
+  order: 10
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('ResourceRegistry — nested-systems lookup regression', () => {
+  it('resolves system metadata for a TOP-LEVEL system path', () => {
+    const topResource: ResourceEntry = {
+      id: 'top-workflow',
+      kind: 'workflow',
+      systemPath: 'acquisition',
+      status: 'active',
+      order: 10
+    }
+    const workflow = makeWorkflow('top-workflow', topResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          systems: { acquisition: topLevelSystemWithChildren },
+          resources: { 'top-workflow': topResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'acquisition',
+      title: 'Acquisition',
+      kind: 'operational',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe('acquisition')
+  })
+
+  it('resolves system metadata for a NESTED system path (the regression case)', () => {
+    const workflow = makeWorkflow('cold-outreach-workflow', nestedSystemResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          // The nested system lives under acquisition.subsystems, NOT as a top-level key.
+          // Before the fix, Object.values(systems) missed this entirely.
+          systems: { acquisition: topLevelSystemWithChildren },
+          resources: { 'cold-outreach-workflow': nestedSystemResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    // Before the fix this was undefined; it must now be defined.
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'outbound',
+      title: 'Outbound',
+      kind: 'operational',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe(NESTED_SYSTEM_PATH)
+    expect(result.workflows[0].governanceStatus).toBe('active')
+  })
+
+  it('resolves system metadata for a THREE-level nested path', () => {
+    const deepSystem: SystemEntry = {
+      id: 'sequences',
+      label: 'Sequences',
+      description: 'Email sequence sub-sub-system.',
+      kind: 'operational',
+      governedByKnowledge: [],
+      drivesGoals: [],
+      lifecycle: 'active',
+      order: 10
+    }
+
+    const outboundWithChildren: SystemEntry = {
+      ...nestedSystem,
+      subsystems: { sequences: deepSystem }
+    }
+
+    const topWithDeepNesting: SystemEntry = {
+      ...topLevelSystem,
+      subsystems: { outbound: outboundWithChildren }
+    }
+
+    const deepResource: ResourceEntry = {
+      id: 'sequence-enroller',
+      kind: 'workflow',
+      systemPath: 'acquisition.outbound.sequences',
+      status: 'active',
+      order: 10
+    }
+
+    const workflow = makeWorkflow('sequence-enroller', deepResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          systems: { acquisition: topWithDeepNesting },
+          resources: { 'sequence-enroller': deepResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'sequences',
+      title: 'Sequences',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe('acquisition.outbound.sequences')
+  })
+
+  it('returns undefined system when the workflow has no resource descriptor and no OM entry', () => {
+    // A workflow with no OM resource descriptor and no organizationModel at all
+    // should leave system undefined (no governance metadata attached).
+    const workflow = makeWorkflow('bare-workflow')
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeUndefined()
+    expect(result.workflows[0].systemPath).toBeUndefined()
+  })
+})

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

@@ -229,13 +229,15 @@ describe('ResourceRegistry', () => {
         kind: 'operational',
         governedByKnowledge: [],
         drivesGoals: [],
-        status: 'active'
+        lifecycle: 'active',
+        order: 10
       }
       const resource: ResourceEntry = {
         id: 'workflow-1',
         kind: 'workflow',
-        systemId: system.id,
-        status: 'active'
+        systemPath: system.id,
+        status: 'active',
+        order: 10
       }
       const workflow = createMockWorkflow('workflow-1')
       workflow.config.resource = resource
@@ -243,8 +245,8 @@ describe('ResourceRegistry', () => {
       const registry = new ResourceRegistry({
         'test-org': {
           organizationModel: {
-            systems: { systems: [system] },
-            resources: { entries: [resource] }
+            systems: { [system.id]: system },
+            resources: { [resource.id]: resource }
           },
           workflows: [workflow]
         }
@@ -254,13 +256,13 @@ describe('ResourceRegistry', () => {
 
       expect(result.workflows[0]).toMatchObject({
         resourceId: 'workflow-1',
-        systemId: 'sys.lead-gen',
+        systemPath: 'sys.lead-gen',
         governanceStatus: 'active',
         system: {
           id: 'sys.lead-gen',
           title: 'Lead Generation',
           kind: 'operational',
-          status: 'active'
+          lifecycle: 'active'
         }
       })
     })

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

@@ -289,7 +289,8 @@ describe('validateResourceGovernance', () => {
     kind: 'operational' as const,
     governedByKnowledge: [],
     drivesGoals: [],
-    status: 'active' as const
+    status: 'active' as const,
+    order: 10
   }
 
   const systemB = {
@@ -299,23 +300,26 @@ describe('validateResourceGovernance', () => {
     kind: 'operational' as const,
     governedByKnowledge: [],
     drivesGoals: [],
-    status: 'active' as const
+    status: 'active' as const,
+    order: 20
   }
 
   const workflowResource: ResourceEntry = {
     id: 'lead-import',
     kind: 'workflow',
-    systemId: 'sys.lead-gen',
-    status: 'active'
+    systemPath: 'sys.lead-gen',
+    status: 'active',
+    order: 10
   }
 
   const agentResource: ResourceEntry = {
     id: 'lead-import',
     kind: 'agent',
-    systemId: 'sys.lead-gen',
+    systemPath: 'sys.lead-gen',
     status: 'active',
     agentKind: 'specialist',
-    sessionCapable: false
+    sessionCapable: false,
+    order: 10
   }
 
   const createGovernedWorkflow = (
@@ -358,8 +362,8 @@ describe('validateResourceGovernance', () => {
   })
 
   const createModel = (resources: ResourceEntry[] = [workflowResource], systems = [systemA]) => ({
-    systems: { systems },
-    resources: { entries: resources }
+    systems: Object.fromEntries(systems.map((s) => [s.id, s])),
+    resources: Object.fromEntries(resources.map((r) => [r.id, r]))
   })
 
   it('passes when code resources are descriptor-backed and match active OM Resources and Systems', () => {
@@ -483,7 +487,7 @@ describe('validateResourceGovernance', () => {
   it('reports descriptor/OM system mismatches', () => {
     const codeDescriptor: ResourceEntry = {
       ...workflowResource,
-      systemId: 'sys.crm'
+      systemPath: 'sys.crm'
     }
 
     expect(() =>
@@ -502,7 +506,7 @@ describe('validateResourceGovernance', () => {
   it('reports active OM resources that reference missing Systems', () => {
     const resourceWithMissingSystem: ResourceEntry = {
       ...workflowResource,
-      systemId: 'sys.missing'
+      systemPath: 'sys.missing'
     }
 
     expect(() =>
@@ -515,7 +519,7 @@ describe('validateResourceGovernance', () => {
         createModel([resourceWithMissingSystem], [systemA]),
         { mode: 'strict' }
       )
-    ).toThrow("OM resource 'lead-import' references missing System 'sys.missing'")
+    ).toThrow("OM resource 'lead-import' references missing system path 'sys.missing'.")
   })
 
   it('reports raw runtime resourceId authoring when a descriptor is required', () => {

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

@@ -11,9 +11,14 @@
 
 import type { WorkflowDefinition } from '../../execution/engine/workflow/types'
 import type { AgentDefinition } from '../../execution/engine/agent/core/types'
-import type { OrganizationModelResources, OrganizationModelSystems } from '../../organization-model/types'
+import type {
+  OrganizationModel,
+  OrganizationModelResources,
+  OrganizationModelSystems
+} 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'
 import type {
   ResourceStatus,
   ResourceDefinition,
@@ -52,10 +57,10 @@ function summarizeSystem(system: SystemEntry | undefined): ResourceDefinition['s
 
   return {
     id: system.id,
-    title: system.title,
+    title: system.label ?? system.title,
     description: system.description,
     kind: system.kind,
-    status: system.status
+    lifecycle: system.lifecycle
   }
 }
 
@@ -303,18 +308,25 @@ export class ResourceRegistry {
       }
     }
 
-    const resourcesById = new Map((orgResources.organizationModel?.resources?.entries ?? []).map((r) => [r.id, r]))
-    const systemsById = new Map((orgResources.organizationModel?.systems?.systems ?? []).map((s) => [s.id, s]))
+    const resourcesById = new Map(Object.values(orgResources.organizationModel?.resources ?? {}).map((r) => [r.id, r]))
+    // Build a path-keyed map that includes nested systems (DFS via listAllSystems).
+    // resource.systemPath is the dot-separated system path used as the lookup key.
+    const omSystems = orgResources.organizationModel?.systems
+    const systemsByPath = new Map<string, SystemEntry>(
+      omSystems
+        ? listAllSystems({ systems: omSystems } as OrganizationModel).map(({ path, system }) => [path, system])
+        : []
+    )
     const getGovernanceMetadata = (
       resourceId: string,
       descriptor: ResourceEntry | undefined
-    ): Pick<ResourceDefinition, 'systemId' | 'system' | 'governanceStatus'> => {
+    ): Pick<ResourceDefinition, 'systemPath' | 'system' | 'governanceStatus'> => {
       const resource = descriptor ?? resourcesById.get(resourceId)
       if (!resource) return {}
 
       return {
-        systemId: resource.systemId,
-        system: summarizeSystem(systemsById.get(resource.systemId)),
+        systemPath: resource.systemPath,
+        system: summarizeSystem(systemsByPath.get(resource.systemPath)),
         governanceStatus: resource.status
       }
     }

package/src/platform/registry/serialization.ts

@@ -24,27 +24,27 @@ function summarizeSystem(system: SystemEntry | undefined): ResourceDefinition['s
 
   return {
     id: system.id,
-    title: system.title,
+    title: system.label ?? system.title,
     description: system.description,
     kind: system.kind,
-    status: system.status
+    lifecycle: system.lifecycle
   }
 }
 
 function createGovernanceMetadataResolver(resources: DeploymentSpec) {
-  const resourcesById = new Map((resources.organizationModel?.resources?.entries ?? []).map((r) => [r.id, r]))
-  const systemsById = new Map((resources.organizationModel?.systems?.systems ?? []).map((s) => [s.id, s]))
+  const resourcesById = new Map(Object.values(resources.organizationModel?.resources ?? {}).map((r) => [r.id, r]))
+  const systemsById = new Map(Object.values(resources.organizationModel?.systems ?? {}).map((s) => [s.id, s]))
 
   return (
     resourceId: string,
     descriptor: ResourceEntry | undefined
-  ): Pick<ResourceDefinition, 'systemId' | 'system' | 'governanceStatus'> => {
+  ): Pick<ResourceDefinition, 'systemPath' | 'system' | 'governanceStatus'> => {
     const resource = descriptor ?? resourcesById.get(resourceId)
     if (!resource) return {}
 
     return {
-      systemId: resource.systemId,
-      system: summarizeSystem(systemsById.get(resource.systemId)),
+      systemPath: resource.systemPath,
+      system: summarizeSystem(systemsById.get(resource.systemPath)),
       governanceStatus: resource.status
     }
   }

package/src/platform/registry/types.ts

@@ -28,7 +28,7 @@ export type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'e
  */
 export type ExecutableResourceType = 'workflow' | 'agent'
 
-export type ResourceSystemSummary = Pick<SystemEntry, 'id' | 'title' | 'description' | 'kind' | 'status'>
+export type ResourceSystemSummary = Pick<SystemEntry, 'id' | 'title' | 'description' | 'kind' | 'lifecycle'>
 
 // ============================================================================
 // Base Resource Interface
@@ -69,8 +69,8 @@ export interface ResourceDefinition {
   /** Whether the resource is local (monorepo) or remote (externally deployed) */
   origin?: 'local' | 'remote'
 
-  /** OM System membership, when backed by a Resource descriptor */
-  systemId?: string
+  /** OM System membership — dot-separated system path (e.g. "sys.lead-gen"), when backed by a Resource descriptor */
+  systemPath?: string
 
   /** Display metadata for the owning OM System */
   system?: ResourceSystemSummary