@elevasis/core 0.19.0 → 0.20.0

package/src/organization-model/graph/build.ts

@@ -7,6 +7,7 @@ import type {
   OrganizationGraphNode,
   OrganizationGraphNodeKind
 } from './types'
+import { CAPABILITY_REGISTRY } from '../domains/prospecting'
 
 function nodeId(kind: OrganizationGraphNodeKind, sourceId?: string): string {
   return kind === 'organization' ? 'organization-model' : `${kind}:${sourceId ?? ''}`
@@ -187,6 +188,79 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
     }
   }
 
+  const allStages = [
+    ...organizationModel.prospecting.companyStages,
+    ...organizationModel.prospecting.contactStages
+  ].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+
+  for (const stage of allStages) {
+    const id = nodeId('stage', stage.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'stage',
+      label: stage.label,
+      sourceId: stage.id,
+      ...(stage.description ? { description: stage.description } : {}),
+      ...(stage.icon ? { icon: stage.icon } : {})
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+  }
+
+  for (const cap of [...CAPABILITY_REGISTRY].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId('capability', cap.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'capability',
+      label: cap.label,
+      sourceId: cap.id,
+      description: cap.description
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+    const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, cap.resourceId)
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('maps_to', id, resourceNode.id),
+      kind: 'maps_to',
+      sourceId: id,
+      targetId: resourceNode.id
+    })
+  }
+
+  for (const template of [...organizationModel.prospecting.buildTemplates].sort((a, b) => a.id.localeCompare(b.id))) {
+    const stepById = new Map(template.steps.map((s) => [s.id, s]))
+    for (const step of [...template.steps].sort((a, b) => a.id.localeCompare(b.id))) {
+      const stageNodeId = nodeId('stage', step.stageKey)
+      const capNodeId = nodeId('capability', step.capabilityKey)
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('uses', stageNodeId, capNodeId, step.id),
+        kind: 'uses',
+        sourceId: stageNodeId,
+        targetId: capNodeId
+      })
+      for (const depId of step.dependsOn ?? []) {
+        const depStep = stepById.get(depId)
+        if (depStep) {
+          const depStageNodeId = nodeId('stage', depStep.stageKey)
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId('references', stageNodeId, depStageNodeId, step.id),
+            kind: 'references',
+            sourceId: stageNodeId,
+            targetId: depStageNodeId
+          })
+        }
+      }
+    }
+  }
+
   if (commandViewData) {
     const commandViewResources = collectCommandViewResources(commandViewData).sort((a, b) =>
       a.resourceId.localeCompare(b.resourceId)

package/src/organization-model/graph/schema.ts

@@ -8,6 +8,7 @@ export const OrganizationGraphNodeKindSchema = z.enum([
   'surface',
   'entity',
   'capability',
+  'stage',
   'resource',
   'knowledge'
 ])

package/src/organization-model/graph/types.ts

@@ -9,6 +9,7 @@ export type OrganizationGraphNodeKind =
   | 'surface'
   | 'entity'
   | 'capability'
+  | 'stage'
   | 'resource'
   | 'knowledge'
 

package/src/organization-model/schema.ts

@@ -70,8 +70,14 @@ function hasFeature(featuresById: Map<string, unknown>, featureId: string): bool
   return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? '')
 }
 
+function defaultFeaturePathFor(id: string): string {
+  return `/${id.replaceAll('.', '/')}`
+}
+
 export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
   const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
+  const featureIdsByEffectivePath = new Map<string, string>()
+
   model.features.forEach((feature, featureIndex) => {
     const segments = feature.id.split('.')
     if (segments.length > 1) {
@@ -88,6 +94,21 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     const hasChildren = model.features.some(
       (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
     )
+    const contributesRoutePath = feature.path !== undefined || !hasChildren
+    if (contributesRoutePath) {
+      const effectivePath = feature.path ?? defaultFeaturePathFor(feature.id)
+      const existingFeatureId = featureIdsByEffectivePath.get(effectivePath)
+      if (existingFeatureId !== undefined) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, feature.path === undefined ? 'id' : 'path'],
+          `Feature "${feature.id}" effective path "${effectivePath}" duplicates feature "${existingFeatureId}"`
+        )
+      } else {
+        featureIdsByEffectivePath.set(effectivePath, feature.id)
+      }
+    }
+
     if (hasChildren && feature.enabled) {
       const hasEnabledDescendant = model.features.some(
         (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
@@ -102,6 +123,48 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     }
   })
 
+  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Navigation surface')
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ['navigation', 'defaultSurfaceId'],
+      `Navigation defaultSurfaceId references unknown surface "${model.navigation.defaultSurfaceId}"`
+    )
+  }
+
+  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}"`
+        )
+      }
+    })
+  })
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.featureId !== undefined && !hasFeature(featuresById, surface.featureId)) {
+      addIssue(
+        ctx,
+        ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        `Navigation surface "${surface.id}" references unknown feature "${surface.featureId}"`
+      )
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (!hasFeature(featuresById, featureId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+          `Navigation surface "${surface.id}" references unknown feature "${featureId}"`
+        )
+      }
+    })
+  })
+
   // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
   const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
   model.offerings.products.forEach((product, productIndex) => {

package/src/organization-model/surface-projection.ts

@@ -0,0 +1,218 @@
+import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from './types'
+
+export type OrganizationSurfaceProjectionIssueCode =
+  | 'duplicate-surface-id'
+  | 'duplicate-surface-path'
+  | 'unknown-default-surface'
+  | 'unknown-group-surface'
+  | 'unknown-surface-feature'
+  | 'unknown-surface-feature-reference'
+
+export interface OrganizationSurfaceProjection {
+  id: string
+  label: string
+  path: string
+  surfaceType: OrganizationModelSurface['surfaceType']
+  featureId?: string
+  featureIds: string[]
+  entityIds: string[]
+  resourceIds: string[]
+  capabilityIds: string[]
+  enabled: boolean
+  devOnly?: boolean
+  requiresAdmin?: boolean
+}
+
+export interface OrganizationSurfaceProjectionIssue {
+  code: OrganizationSurfaceProjectionIssueCode
+  message: string
+  path: Array<string | number>
+  surfaceId?: string
+  featureId?: string
+  groupId?: string
+  value?: string
+}
+
+const LEGACY_FEATURE_ALIASES = new Map<string, string>([
+  ['crm', 'sales.crm'],
+  ['lead-gen', 'sales.lead-gen'],
+  ['submitted-requests', 'monitoring.submitted-requests']
+])
+
+function normalizePath(path: string): string {
+  return path.length > 1 ? path.replace(/\/+$/, '') : path
+}
+
+function collectFeaturesById(model: OrganizationModel): Map<string, OrganizationModelFeature> {
+  return new Map(model.features.map((feature) => [feature.id, feature]))
+}
+
+function resolveFeatureId(featuresById: Map<string, OrganizationModelFeature>, featureId: string): string | undefined {
+  if (featuresById.has(featureId)) {
+    return featureId
+  }
+
+  const aliasTarget = LEGACY_FEATURE_ALIASES.get(featureId)
+  return aliasTarget !== undefined && featuresById.has(aliasTarget) ? aliasTarget : undefined
+}
+
+function getFeatureWithAncestors(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureId: string
+): OrganizationModelFeature[] {
+  const features: OrganizationModelFeature[] = []
+  const segments = featureId.split('.')
+
+  for (let index = 1; index <= segments.length; index += 1) {
+    const candidate = featuresById.get(segments.slice(0, index).join('.'))
+    if (candidate) {
+      features.push(candidate)
+    }
+  }
+
+  return features
+}
+
+function hasInheritedFlag(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureIds: string[],
+  flag: 'devOnly' | 'requiresAdmin'
+): boolean {
+  return featureIds.some((featureId) =>
+    getFeatureWithAncestors(featuresById, featureId).some((feature) => feature[flag] === true)
+  )
+}
+
+function isFeatureEnabled(featuresById: Map<string, OrganizationModelFeature>, featureId: string): boolean {
+  const featureLineage = getFeatureWithAncestors(featuresById, featureId)
+  return featureLineage.length > 0 && featureLineage.every((feature) => feature.enabled)
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+export function projectOrganizationSurfaces(model: OrganizationModel): OrganizationSurfaceProjection[] {
+  const featuresById = collectFeaturesById(model)
+
+  return model.navigation.surfaces.map((surface) => {
+    const featureId = surface.featureId ? resolveFeatureId(featuresById, surface.featureId) : undefined
+    const featureIds = unique(
+      [featureId, ...surface.featureIds.map((candidate) => resolveFeatureId(featuresById, candidate))].filter(
+        (candidate): candidate is string => candidate !== undefined
+      )
+    )
+    const enabled = surface.enabled && featureIds.every((candidate) => isFeatureEnabled(featuresById, candidate))
+    const devOnly = surface.devOnly === true || hasInheritedFlag(featuresById, featureIds, 'devOnly')
+    const requiresAdmin = hasInheritedFlag(featuresById, featureId ? [featureId] : featureIds, 'requiresAdmin')
+
+    return {
+      id: surface.id,
+      label: surface.label,
+      path: surface.path,
+      surfaceType: surface.surfaceType,
+      featureId,
+      featureIds,
+      entityIds: [...surface.entityIds],
+      resourceIds: [...surface.resourceIds],
+      capabilityIds: [...surface.capabilityIds],
+      enabled,
+      ...(devOnly ? { devOnly } : {}),
+      ...(requiresAdmin ? { requiresAdmin } : {})
+    }
+  })
+}
+
+export function validateOrganizationSurfaceProjection(model: OrganizationModel): OrganizationSurfaceProjectionIssue[] {
+  const issues: OrganizationSurfaceProjectionIssue[] = []
+  const featuresById = collectFeaturesById(model)
+  const surfaceIds = new Set<string>()
+  const surfacePaths = new Map<string, string>()
+
+  function addIssue(issue: OrganizationSurfaceProjectionIssue): void {
+    issues.push(issue)
+  }
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surfaceIds.has(surface.id)) {
+      addIssue({
+        code: 'duplicate-surface-id',
+        message: `Surface id "${surface.id}" must be unique`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'id'],
+        surfaceId: surface.id,
+        value: surface.id
+      })
+    } else {
+      surfaceIds.add(surface.id)
+    }
+
+    const normalizedPath = normalizePath(surface.path)
+    const existingSurfaceId = surfacePaths.get(normalizedPath)
+    if (existingSurfaceId !== undefined) {
+      addIssue({
+        code: 'duplicate-surface-path',
+        message: `Surface path "${surface.path}" is already used by surface "${existingSurfaceId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'path'],
+        surfaceId: surface.id,
+        value: surface.path
+      })
+    } else {
+      surfacePaths.set(normalizedPath, surface.id)
+    }
+
+    if (surface.featureId !== undefined && resolveFeatureId(featuresById, surface.featureId) === undefined) {
+      addIssue({
+        code: 'unknown-surface-feature',
+        message: `Surface "${surface.id}" references unknown feature "${surface.featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        surfaceId: surface.id,
+        featureId: surface.featureId,
+        value: surface.featureId
+      })
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (resolveFeatureId(featuresById, featureId) !== undefined) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-surface-feature-reference',
+        message: `Surface "${surface.id}" references unknown feature "${featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+        surfaceId: surface.id,
+        featureId,
+        value: featureId
+      })
+    })
+  })
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfaceIds.has(model.navigation.defaultSurfaceId)) {
+    addIssue({
+      code: 'unknown-default-surface',
+      message: `Default surface "${model.navigation.defaultSurfaceId}" is not declared in navigation.surfaces`,
+      path: ['navigation', 'defaultSurfaceId'],
+      surfaceId: model.navigation.defaultSurfaceId,
+      value: model.navigation.defaultSurfaceId
+    })
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (surfaceIds.has(surfaceId)) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-group-surface',
+        message: `Navigation group "${group.id}" references unknown surface "${surfaceId}"`,
+        path: ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+        surfaceId,
+        groupId: group.id,
+        value: surfaceId
+      })
+    })
+  })
+
+  return issues
+}

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.8.1'
+  CURRENT: '1.8.6'
 }

package/src/reference/_generated/contracts.md

@@ -1123,7 +1123,7 @@ export const DEFAULT_CRM_PRIORITY_RULE_CONFIG: CrmPriorityRuleConfig = {
 ### `DealStageSchema`
 
 ```typescript
-export const DealStageSchema = z.enum(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])
+export const DealStageSchema = CrmStageKeySchema
 ```
 
 ### `AcqDealTaskKindSchema`
@@ -1215,7 +1215,7 @@ export const TransitionItemRequestSchema = z
   .object({
     pipelineKey: z.string().min(1),
     stageKey: z.string().min(1),
-    stateKey: z.string().nullable().optional(),
+    stateKey: z.string().min(1).nullable().optional(),
     reason: z.string().optional(),
     expectedUpdatedAt: z.string().datetime().optional()
   })
@@ -1409,6 +1409,11 @@ export const DealTaskListResponseSchema = z.array(DealTaskResponseSchema)
 
 ```typescript
 export const DealSchemas = {
+  // Primitives
+  CrmStageKey: CrmStageKeySchema,
+  CrmStateKey: CrmStateKeySchema,
+  DealStage: DealStageSchema,
+
   // Params
   DealIdParams: DealIdParamsSchema,
   DealTaskIdParams: DealTaskIdParamsSchema,
@@ -1421,7 +1426,7 @@ export const DealSchemas = {
   // Request bodies
   CreateDealNoteRequest: CreateDealNoteRequestSchema,
   CreateDealTaskRequest: CreateDealTaskRequestSchema,
-  TransitionItemRequest: TransitionItemRequestSchema,
+  TransitionItemRequest: CrmTransitionItemRequestSchema,
   TransitionDealStateRequest: TransitionDealStateRequestSchema,
   ExecuteActionParams: ExecuteActionParamsSchema,
   ExecuteActionRequest: ExecuteActionRequestSchema,
@@ -2552,7 +2557,7 @@ export const AcqSubstrateSchemas = {
   ListCompanyIdParams: ListCompanyIdParamsSchema,
   AcqListCompanyResponse: AcqListCompanyResponseSchema,
 
-  // Transition (shared with deals — TransitionItemRequestSchema)
+  // Transition (generic stateful substrate)
   TransitionItemRequest: TransitionItemRequestSchema
 }
 ```
@@ -2620,6 +2625,8 @@ export interface StatefulStageDefinition {
   /** Matches stage_key values written by workflow steps. */
   stageKey: string
   label: string
+  /** UI color token. Consumers may map this to their design system. */
+  color?: string
   states: StatefulStateDefinition[]
 }
 ```