@elevasis/core 0.21.0 → 0.23.0

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

@@ -4,27 +4,32 @@ import type { OrganizationGraph } from '../../../organization-model/graph/types'
 
 describe('resource-link', () => {
   it('parses resource links and categories', () => {
-    expect(ResourceLinkSchema.parse({ nodeId: 'feature:sales.crm', kind: 'operates-on' })).toEqual({
-      nodeId: 'feature:sales.crm',
-      kind: 'operates-on'
+    expect(ResourceLinkSchema.parse({ nodeId: 'system:sales.crm', kind: 'references' })).toEqual({
+      nodeId: 'system:sales.crm',
+      kind: 'references'
     })
     expect(ResourceCategorySchema.parse('diagnostic')).toBe('diagnostic')
   })
 
   it('rejects node ids without a kind prefix', () => {
-    expect(() => ResourceLinkSchema.parse({ nodeId: 'sales.crm', kind: 'operates-on' })).toThrow()
+    expect(() => ResourceLinkSchema.parse({ nodeId: 'sales.crm', kind: 'references' })).toThrow()
+  })
+
+  it('rejects retired ad hoc resource-operation links', () => {
+    const retiredKind = ['operates', 'on'].join('-')
+    expect(() => ResourceLinkSchema.parse({ nodeId: 'system:sales.crm', kind: retiredKind })).toThrow()
   })
 
   it('builds and validates graph node ids', () => {
     const graph: OrganizationGraph = {
       version: 1,
       organizationModelVersion: 1,
-      nodes: [{ id: 'feature:sales.crm', kind: 'feature', label: 'CRM', sourceId: 'sales.crm' }],
+      nodes: [{ id: 'system:sales.crm', kind: 'system', label: 'CRM', sourceId: 'sales.crm' }],
       edges: []
     }
 
-    expect(kindPrefix('feature', 'sales.crm')).toBe('feature:sales.crm')
-    expect(() => validateNodeId('feature:sales.crm', graph)).not.toThrow()
-    expect(() => validateNodeId('feature:missing', graph)).toThrow(/Unknown organization graph node/)
+    expect(kindPrefix('system', 'sales.crm')).toBe('system:sales.crm')
+    expect(() => validateNodeId('system:sales.crm', graph)).not.toThrow()
+    expect(() => validateNodeId('system:missing', graph)).toThrow(/Unknown organization graph node/)
   })
 })

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()
+  })
+})