@elevasis/core 0.10.0 → 0.11.1

package/src/organization-model/schema.ts

@@ -1,36 +1,34 @@
 import { z } from 'zod'
-import { OrganizationModelBrandingSchema } from './domains/branding'
-import { OrganizationModelSalesSchema } from './domains/sales'
-import { OrganizationModelProjectsSchema } from './domains/projects'
-import { FeatureSchema } from './domains/features'
-import { OrganizationModelProspectingSchema } from './domains/prospecting'
-import { OrganizationModelNavigationSchema } from './domains/navigation'
-import { ResourceMappingSchema } from './domains/shared'
-import { IdentityDomainSchema, DEFAULT_ORGANIZATION_MODEL_IDENTITY } from './domains/identity'
-import { CustomersDomainSchema, DEFAULT_ORGANIZATION_MODEL_CUSTOMERS } from './domains/customers'
-import { OfferingsDomainSchema, DEFAULT_ORGANIZATION_MODEL_OFFERINGS } from './domains/offerings'
+import { OrganizationModelBrandingSchema } from './domains/branding'
+import { OrganizationModelSalesSchema } from './domains/sales'
+import { OrganizationModelProjectsSchema } from './domains/projects'
+import { FeatureSchema } from './domains/features'
+import { OrganizationModelProspectingSchema } from './domains/prospecting'
+import { OrganizationModelNavigationSchema } from './domains/navigation'
+import { IdentityDomainSchema, DEFAULT_ORGANIZATION_MODEL_IDENTITY } from './domains/identity'
+import { CustomersDomainSchema, DEFAULT_ORGANIZATION_MODEL_CUSTOMERS } from './domains/customers'
+import { OfferingsDomainSchema, DEFAULT_ORGANIZATION_MODEL_OFFERINGS } from './domains/offerings'
 import { RolesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { GoalsDomainSchema, DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
 import { OperationsDomainSchema } from './domains/operations'
 import { StatusesDomainSchema } from './domains/statuses'
 
 const OrganizationModelSchemaBase = z.object({
-  version: z.literal(1).default(1),
-  features: z.array(FeatureSchema).default([]),
-  branding: OrganizationModelBrandingSchema,
-  navigation: OrganizationModelNavigationSchema,
-  sales: OrganizationModelSalesSchema,
-  prospecting: OrganizationModelProspectingSchema,
-  projects: OrganizationModelProjectsSchema,
+  version: z.literal(1).default(1),
+  features: z.array(FeatureSchema).default([]),
+  branding: OrganizationModelBrandingSchema,
+  navigation: OrganizationModelNavigationSchema.default({ surfaces: [], groups: [] }),
+  sales: OrganizationModelSalesSchema,
+  prospecting: OrganizationModelProspectingSchema,
+  projects: OrganizationModelProjectsSchema,
   identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
   customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
   offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
   roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
-  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
-  statuses: StatusesDomainSchema.default({ entries: [] }),
-  operations: OperationsDomainSchema.default({ entries: [] }),
-  resourceMappings: z.array(ResourceMappingSchema).default([])
-})
+  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
+  statuses: StatusesDomainSchema.default({ entries: [] }),
+  operations: OperationsDomainSchema.default({ entries: [] })
+})
 
 function addIssue(ctx: z.RefinementCtx, path: Array<string | number>, message: string): void {
   ctx.addIssue({
@@ -40,7 +38,7 @@ function addIssue(ctx: z.RefinementCtx, path: Array<string | number>, message: s
   })
 }
 
-function collectIds<T extends { id: string }>(
+function collectIds<T extends { id: string }>(
   items: T[],
   ctx: z.RefinementCtx,
   collectionPath: Array<string | number>,
@@ -57,144 +55,46 @@ function collectIds<T extends { id: string }>(
     itemsById.set(item.id, item)
   })
 
-  return itemsById
-}
-
-export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
-  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Surface')
-  collectIds(model.navigation.groups, ctx, ['navigation', 'groups'], 'Navigation group')
-  collectIds(model.resourceMappings, ctx, ['resourceMappings'], 'Resource mapping')
-
-  const resourceMappingsByResourceId = new Map<string, (typeof model.resourceMappings)[number]>()
-  model.resourceMappings.forEach((resourceMapping, index) => {
-    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
-      addIssue(
-        ctx,
-        ['resourceMappings', index, 'resourceId'],
-        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
-      )
-      return
-    }
-
-    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping)
-  })
-
-  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
-    addIssue(
-      ctx,
-      ['navigation', 'defaultSurfaceId'],
-      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
-    )
-  }
-
-  model.navigation.groups.forEach((group, groupIndex) => {
-    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      if (!surfacesById.has(surfaceId)) {
-        addIssue(
-          ctx,
-          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
-          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
-        )
-      }
-    })
-  })
-
-  // Feature -> Surface bidirectional validation
-  model.features.forEach((feature, featureIndex) => {
-    feature.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references surface "${surfaceId}" but that surface does not include feature "${feature.id}"`
-        )
-      }
-    })
-
-    // Feature -> Resource bidirectional validation
-    feature.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references resource "${resourceId}" but that resource mapping does not include feature "${feature.id}"`
-        )
-      }
-    })
-  })
-
-  // Surface -> Feature bidirectional validation and other surface refs
-  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
-    if (surface.parentId && !surfacesById.has(surface.parentId)) {
-      addIssue(
-        ctx,
-        ['navigation', 'surfaces', surfaceIndex, 'parentId'],
-        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
-      )
-    }
-
-    surface.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references feature "${featureId}" but that feature does not include surface "${surface.id}"`
-        )
-      }
-    })
-
-    // Surface -> Resource bidirectional validation
-    surface.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references resource "${resourceId}" but that surface does not include resource "${surface.id}"`
-        )
-      }
-    })
-  })
+  return itemsById
+}
+
+const LEGACY_FEATURE_ALIASES = new Map<string, string>([
+  ['crm', 'sales.crm'],
+  ['lead-gen', 'sales.lead-gen'],
+  ['submitted-requests', 'monitoring.submitted-requests']
+])
+
+function hasFeature(featuresById: Map<string, unknown>, featureId: string): boolean {
+  return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? '')
+}
+
+export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
+  model.features.forEach((feature, featureIndex) => {
+    const segments = feature.id.split('.')
+    if (segments.length > 1) {
+      const parentId = segments.slice(0, -1).join('.')
+      if (!featuresById.has(parentId)) {
+        addIssue(ctx, ['features', featureIndex, 'id'], `Feature "${feature.id}" references unknown parent "${parentId}"`)
+      }
+    }
+
+    const hasChildren = model.features.some(
+      (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
+    )
+    if (hasChildren && feature.enabled) {
+      const hasEnabledDescendant = model.features.some(
+        (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
+      )
+      if (!hasEnabledDescendant) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, 'enabled'],
+          `Feature "${feature.id}" is enabled but has no enabled descendants`
+        )
+      }
+    }
+  })
 
   // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
   const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
@@ -210,7 +110,7 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     })
 
     // Offerings -> Feature cross-ref: deliveryFeatureId must resolve (when present)
-    if (product.deliveryFeatureId !== undefined && !featuresById.has(product.deliveryFeatureId)) {
+    if (product.deliveryFeatureId !== undefined && !hasFeature(featuresById, product.deliveryFeatureId)) {
       addIssue(
         ctx,
         ['offerings', 'products', productIndex, 'deliveryFeatureId'],
@@ -242,46 +142,4 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     }
   })
 
-  // ResourceMapping -> Feature and Surface bidirectional validation
-  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
-    resourceMapping.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references feature "${featureId}" but that feature does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-
-    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-  })
-})
+})

package/src/organization-model/types.ts

@@ -1,11 +1,11 @@
 import type { z } from 'zod'
 import { OrganizationModelBrandingSchema } from './domains/branding'
 import { OrganizationModelSalesSchema } from './domains/sales'
-import { OrganizationModelProjectsSchema } from './domains/projects'
-import { FeatureSchema } from './domains/features'
-import { OrganizationModelProspectingSchema } from './domains/prospecting'
-import { OrganizationModelNavigationSchema, SurfaceDefinitionSchema } from './domains/navigation'
-import { ResourceMappingSchema, TechStackEntrySchema } from './domains/shared'
+import { OrganizationModelProjectsSchema } from './domains/projects'
+import { FeatureSchema, NodeIdPathSchema, NodeIdStringSchema } from './domains/features'
+import { OrganizationModelProspectingSchema } from './domains/prospecting'
+import { OrganizationModelNavigationSchema, SurfaceDefinitionSchema } from './domains/navigation'
+import { TechStackEntrySchema } from './domains/shared'
 import { OperationsDomainSchema, OperationEntrySchema, OperationSemanticClassSchema } from './domains/operations'
 import { StatusesDomainSchema, StatusEntrySchema, StatusSemanticClassSchema } from './domains/statuses'
 import { CustomersDomainSchema, CustomerSegmentSchema, FirmographicsSchema } from './domains/customers'
@@ -18,12 +18,13 @@ export type OrganizationModel = z.infer<typeof OrganizationModelSchema>
 export type OrganizationModelBranding = z.infer<typeof OrganizationModelBrandingSchema>
 export type OrganizationModelSales = z.infer<typeof OrganizationModelSalesSchema>
 export type OrganizationModelProspecting = z.infer<typeof OrganizationModelProspectingSchema>
-export type OrganizationModelProjects = z.infer<typeof OrganizationModelProjectsSchema>
-export type OrganizationModelFeature = z.infer<typeof FeatureSchema>
-export type OrganizationModelNavigation = z.infer<typeof OrganizationModelNavigationSchema>
-export type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
-export type OrganizationModelResourceMapping = z.infer<typeof ResourceMappingSchema>
-export type OrganizationModelTechStackEntry = z.infer<typeof TechStackEntrySchema>
+export type OrganizationModelProjects = z.infer<typeof OrganizationModelProjectsSchema>
+export type OrganizationModelFeature = z.infer<typeof FeatureSchema>
+export type NodeIdPath = z.infer<typeof NodeIdPathSchema>
+export type NodeIdString = z.infer<typeof NodeIdStringSchema>
+export type OrganizationModelNavigation = z.infer<typeof OrganizationModelNavigationSchema>
+export type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
+export type OrganizationModelTechStackEntry = z.infer<typeof TechStackEntrySchema>
 export type OrganizationModelStatuses = z.infer<typeof StatusesDomainSchema>
 export type OrganizationModelStatusEntry = z.infer<typeof StatusEntrySchema>
 export type OrganizationModelStatusSemanticClass = z.infer<typeof StatusSemanticClassSchema>

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
-export const VERSION = {
-  CURRENT: '1.6.9'
-}
+export const VERSION = {
+  CURRENT: '1.6.10'
+}

package/src/platform/registry/__tests__/command-view.test.ts

@@ -37,10 +37,11 @@ const mockAgent: CommandViewAgent = {
   status: 'dev',
   modelProvider: 'anthropic',
   modelId: 'claude-sonnet-4-20250514',
-  toolCount: 5,
-  hasKnowledgeMap: true,
-  hasMemory: false,
-  domains: ['support', 'sales']
+  toolCount: 5,
+  hasKnowledgeMap: true,
+  hasMemory: false,
+  links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }],
+  category: 'production'
 }
 
 const mockWorkflow: CommandViewWorkflow = {
@@ -52,7 +53,7 @@ const mockWorkflow: CommandViewWorkflow = {
   status: 'prod',
   stepCount: 3,
   entryPoint: 'start',
-  domains: ['support']
+  links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
 }
 
 const mockTrigger: TriggerDefinition = {

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { ResourceCategorySchema, ResourceLinkSchema, kindPrefix, validateNodeId } from '../resource-link'
+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(ResourceCategorySchema.parse('diagnostic')).toBe('diagnostic')
+  })
+
+  it('rejects node ids without a kind prefix', () => {
+    expect(() => ResourceLinkSchema.parse({ nodeId: 'sales.crm', kind: 'operates-on' })).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' }],
+      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/)
+  })
+})

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

@@ -35,16 +35,16 @@ describe('ResourceRegistry Integration', () => {
   const createMockWorkflow = (
     resourceId: string,
     status: 'dev' | 'prod' = 'dev',
-    domains?: string[]
+    links?: Array<{ nodeId: string; kind: 'operates-on' }>
   ): WorkflowDefinition => ({
     config: {
       resourceId,
       name: `Workflow ${resourceId}`,
       description: `Test workflow ${resourceId}`,
-      version: '1.0.0',
-      type: 'workflow',
-      status,
-      domains
+      version: '1.0.0',
+      type: 'workflow',
+      status,
+      links
     },
     contract: {
       inputSchema: z.object({ data: z.string() }),
@@ -67,17 +67,17 @@ describe('ResourceRegistry Integration', () => {
   const createMockAgent = (
     resourceId: string,
     status: 'dev' | 'prod' = 'dev',
-    domains?: string[]
+    links?: Array<{ nodeId: string; kind: 'operates-on' }>
   ): AgentDefinition => ({
     config: {
       resourceId,
       name: `Agent ${resourceId}`,
       description: `Test agent ${resourceId}`,
       version: '1.0.0',
-      type: 'agent',
-      status,
-      systemPrompt: 'You are a test agent',
-      domains
+      type: 'agent',
+      status,
+      systemPrompt: 'You are a test agent',
+      links
     },
     contract: {
       inputSchema: z.object({ query: z.string() }),
@@ -116,7 +116,7 @@ describe('ResourceRegistry Integration', () => {
         description: 'Webhook from Shopify on new orders',
         status: 'prod',
         webhookPath: '/webhooks/shopify/orders',
-        domains: ['sales']
+        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
       },
       {
         resourceId: 'trigger-schedule-support',
@@ -127,7 +127,7 @@ describe('ResourceRegistry Integration', () => {
         description: 'Check for new support tickets every hour',
         status: 'dev',
         schedule: '0 * * * *',
-        domains: ['support']
+        links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
       },
       {
         resourceId: 'trigger-manual-test',
@@ -150,7 +150,7 @@ describe('ResourceRegistry Integration', () => {
         credentialName: 'shopify-prod',
         name: 'Shopify Production',
         description: 'E-commerce platform',
-        domains: ['sales']
+        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
       },
       {
         resourceId: 'integration-zendesk',
@@ -161,7 +161,7 @@ describe('ResourceRegistry Integration', () => {
         credentialName: 'zendesk-dev',
         name: 'Zendesk Support',
         description: 'Support ticket system',
-        domains: ['support']
+        links: [{ nodeId: 'feature:monitoring.submitted-requests', kind: 'operates-on' }]
       }
     ]
 
@@ -202,7 +202,7 @@ describe('ResourceRegistry Integration', () => {
         status: 'prod',
         requestedBy: { agents: ['order-agent'] },
         routesTo: { workflows: ['order-workflow'] },
-        domains: ['sales']
+        links: [{ nodeId: 'feature:sales.crm', kind: 'operates-on' }]
       },
       {
         resourceId: 'approval-escalation',

package/src/platform/registry/command-view.ts

@@ -10,12 +10,11 @@
 
 import type {
   ResourceDefinition,
-  TriggerDefinition,
-  IntegrationDefinition,
-  ExternalResourceDefinition,
-  HumanCheckpointDefinition,
-  DomainDefinition
-} from './types'
+  TriggerDefinition,
+  IntegrationDefinition,
+  ExternalResourceDefinition,
+  HumanCheckpointDefinition
+} from './types'
 
 // ============================================================================
 // Node Types - Resources that appear in the graph
@@ -102,12 +101,11 @@ export interface CommandViewData {
   workflows: CommandViewWorkflow[]
   agents: CommandViewAgent[]
   triggers: TriggerDefinition[]
-  integrations: IntegrationDefinition[]
-  externalResources: ExternalResourceDefinition[]
-  humanCheckpoints: HumanCheckpointDefinition[]
-  edges: CommandViewEdge[]
-  domainDefinitions?: DomainDefinition[]
-}
+  integrations: IntegrationDefinition[]
+  externalResources: ExternalResourceDefinition[]
+  humanCheckpoints: HumanCheckpointDefinition[]
+  edges: CommandViewEdge[]
+}
 
 // ============================================================================
 // Type Guards