@elevasis/core 0.19.0 → 0.20.0

package/src/business/acquisition/derive-actions.test.ts

@@ -20,7 +20,7 @@ function makeDeal(
     organization_id: 'org-fixture-id',
     contact_id: null,
     contact_email: 'fixture@example.com',
-    pipeline_key: 'default',
+    pipeline_key: 'crm',
     stage_key: null,
     state_key: null,
     activity_log: [],

package/src/business/acquisition/types.ts

@@ -1,5 +1,5 @@
 import type { Database } from '../../supabase/database.types'
-import type { CAPABILITY_REGISTRY } from '../../organization-model/domains/prospecting'
+import type { Capability } from '../../organization-model/domains/prospecting'
 import type { LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
 import type { PipelineStage, ProcessingStageStatus } from './api-schemas'
 
@@ -52,7 +52,7 @@ export interface WebPost {
 }
 
 export type LeadGenStageKey = (typeof LEAD_GEN_STAGE_CATALOG)[keyof typeof LEAD_GEN_STAGE_CATALOG]['key']
-export type LeadGenCapabilityKey = keyof typeof CAPABILITY_REGISTRY
+export type LeadGenCapabilityKey = Capability['id']
 
 export interface ProcessingStateEntry {
   status: ProcessingStageStatus

package/src/business/deals/api-schemas.ts

@@ -27,7 +27,7 @@ export {
   // Request body schemas
   CreateDealNoteRequestSchema,
   CreateDealTaskRequestSchema,
-  TransitionItemRequestSchema,
+  CrmTransitionItemRequestSchema as TransitionItemRequestSchema,
   TransitionDealStateRequestSchema,
   ExecuteActionParamsSchema,
   ExecuteActionRequestSchema,
@@ -61,7 +61,7 @@ export {
   type ListDealTasksDueQuery,
   type CreateDealNoteRequest,
   type CreateDealTaskRequest,
-  type TransitionItemRequest,
+  type CrmTransitionItemRequest as TransitionItemRequest,
   type TransitionDealStateRequest,
   type ExecuteActionParams,
   type ExecuteActionRequest,

package/src/organization-model/__tests__/graph.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { buildOrganizationGraph } from '../graph/build'
+import { CAPABILITY_REGISTRY } from '../domains/prospecting'
 import { resolveOrganizationModel } from '../resolve'
 
 describe('organization graph', () => {
@@ -11,7 +12,9 @@ describe('organization graph', () => {
       sourceId: 'sales.crm',
       label: 'CRM'
     })
-    expect(graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')).toMatchObject({
+    expect(
+      graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')
+    ).toMatchObject({
       kind: 'contains'
     })
   })
@@ -74,9 +77,112 @@ describe('organization graph', () => {
       kind: 'resource',
       label: 'missing-resource'
     })
-    expect(graph.edges.find((edge) => edge.id.includes('uses'))).toMatchObject({
+    expect(graph.edges.find((edge) => edge.kind === 'references' && edge.relationshipType === 'uses')).toMatchObject({
       kind: 'references',
       relationshipType: 'uses'
     })
   })
+
+  it('projects stage nodes from prospecting lifecycle stages', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const stageNodes = graph.nodes.filter((node) => node.kind === 'stage')
+    expect(stageNodes.length).toBeGreaterThan(0)
+
+    const populated = graph.nodes.find((node) => node.id === 'stage:populated')
+    expect(populated).toMatchObject({ kind: 'stage', sourceId: 'populated' })
+    expect(populated?.label).toBeTruthy()
+
+    expect(graph.edges.find((edge) => edge.kind === 'contains' && edge.targetId === 'stage:populated')).toMatchObject({
+      sourceId: 'organization-model'
+    })
+  })
+
+  it('projects capability nodes from CAPABILITY_REGISTRY with maps_to edges to resources', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const capabilityNodes = graph.nodes.filter((node) => node.kind === 'capability')
+    expect(capabilityNodes).toHaveLength(CAPABILITY_REGISTRY.length)
+
+    const sample = CAPABILITY_REGISTRY[0]
+    const node = graph.nodes.find((n) => n.id === `capability:${sample.id}`)
+    expect(node).toMatchObject({
+      kind: 'capability',
+      sourceId: sample.id,
+      label: sample.label,
+      description: sample.description
+    })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'maps_to' &&
+          edge.sourceId === `capability:${sample.id}` &&
+          edge.targetId === `resource:${sample.resourceId}`
+      )
+    ).toBeDefined()
+
+    expect(graph.nodes.find((n) => n.id === `resource:${sample.resourceId}`)).toBeDefined()
+  })
+
+  it('emits uses edges from stages to capabilities for every prospecting build-template step', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      for (const step of template.steps) {
+        const stageNodeId = `stage:${step.stageKey}`
+        const capNodeId = `capability:${step.capabilityKey}`
+        expect(
+          graph.edges.find(
+            (edge) =>
+              edge.kind === 'uses' &&
+              edge.sourceId === stageNodeId &&
+              edge.targetId === capNodeId &&
+              edge.id.includes(step.id)
+          ),
+          `${template.id}.${step.id}: ${stageNodeId} uses ${capNodeId}`
+        ).toBeDefined()
+      }
+    }
+  })
+
+  it('emits references edges between stages for every step dependsOn link', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      const stepById = new Map(template.steps.map((s) => [s.id, s]))
+      for (const step of template.steps) {
+        for (const depId of step.dependsOn ?? []) {
+          const depStep = stepById.get(depId)
+          if (!depStep) continue
+          const stageNodeId = `stage:${step.stageKey}`
+          const depStageNodeId = `stage:${depStep.stageKey}`
+          expect(
+            graph.edges.find(
+              (edge) =>
+                edge.kind === 'references' &&
+                edge.sourceId === stageNodeId &&
+                edge.targetId === depStageNodeId &&
+                edge.id.includes(step.id)
+            ),
+            `${template.id}.${step.id} dependsOn ${depId}`
+          ).toBeDefined()
+        }
+      }
+    }
+  })
 })

package/src/organization-model/__tests__/prospecting-ssot.test.ts

@@ -1,12 +1,8 @@
 import { describe, expect, it } from 'vitest'
 import { LEAD_GEN_STAGE_CATALOG } from '../domains/sales'
-import {
-  CAPABILITY_REGISTRY,
-  DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
-  PROSPECTING_STEPS
-} from '../domains/prospecting'
+import { CAPABILITY_REGISTRY, DEFAULT_ORGANIZATION_MODEL_PROSPECTING, PROSPECTING_STEPS } from '../domains/prospecting'
 
-const EXPECTED_CAPABILITY_REGISTRY = {
+const EXPECTED_CAPABILITY_RESOURCE_BY_ID: Record<string, string> = {
   'lead-gen.company.source': 'lgn-import-workflow',
   'lead-gen.company.apollo-import': 'lgn-01c-apollo-import-workflow',
   'lead-gen.contact.discover': 'lgn-04-email-discovery-workflow',
@@ -56,7 +52,7 @@ describe('prospecting organization-model SSOT', () => {
   })
 
   it('uses registered capabilities for every prospecting step', () => {
-    const capabilityKeys = new Set(Object.keys(CAPABILITY_REGISTRY))
+    const capabilityKeys = new Set(CAPABILITY_REGISTRY.map((c) => c.id))
 
     for (const templateSteps of Object.values(PROSPECTING_STEPS)) {
       for (const step of Object.values(templateSteps)) {
@@ -88,7 +84,8 @@ describe('prospecting organization-model SSOT', () => {
   })
 
   it('covers all known lead-gen capability registry entries', () => {
-    expect(CAPABILITY_REGISTRY).toEqual(EXPECTED_CAPABILITY_REGISTRY)
-    expect(Object.keys(CAPABILITY_REGISTRY)).toHaveLength(12)
+    expect(CAPABILITY_REGISTRY).toHaveLength(12)
+    const actualResourceById = Object.fromEntries(CAPABILITY_REGISTRY.map((c) => [c.id, c.resourceId]))
+    expect(actualResourceById).toEqual(EXPECTED_CAPABILITY_RESOURCE_BY_ID)
   })
 })

package/src/organization-model/__tests__/schema.test.ts

@@ -14,6 +14,20 @@ function makeFeature(id: string, path = `/${id.replaceAll('.', '/')}`) {
   }
 }
 
+function makeSurface(id: string, featureId?: string, featureIds: string[] = []) {
+  return {
+    id,
+    label: id,
+    path: `/${id.replaceAll('.', '/')}`,
+    surfaceType: 'page' as const,
+    featureId,
+    featureIds,
+    entityIds: [],
+    resourceIds: [],
+    capabilityIds: []
+  }
+}
+
 function makeMinimalModel(features: unknown[] = []) {
   return {
     version: 1 as const,
@@ -48,6 +62,22 @@ describe('flat feature tree validation', () => {
     expect(messages.some((message) => message.includes('Feature id "sales" must be unique'))).toBe(true)
   })
 
+  it('rejects duplicate effective feature paths when explicit and default paths collide', () => {
+    const messages = getIssueMessages(
+      makeMinimalModel([
+        { id: 'sales', label: 'Sales', enabled: true },
+        makeFeature('sales.crm', '/sales/lead-gen'),
+        { id: 'sales.lead-gen', label: 'Lead Gen', enabled: true }
+      ])
+    )
+
+    expect(
+      messages.some((message) =>
+        message.includes('Feature "sales.lead-gen" effective path "/sales/lead-gen" duplicates feature "sales.crm"')
+      )
+    ).toBe(true)
+  })
+
   it('rejects a dotted child when its immediate parent is missing', () => {
     const messages = getIssueMessages(makeMinimalModel([makeFeature('sales.crm.pipeline')]))
 
@@ -80,4 +110,96 @@ describe('flat feature tree validation', () => {
     expect(model.navigation.groups).toEqual([])
     expect('resourceMappings' in model).toBe(false)
   })
+
+  it('rejects an unknown navigation default surface when surfaces are explicitly empty', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        defaultSurfaceId: 'missing.surface',
+        surfaces: [],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation defaultSurfaceId references unknown surface "missing.surface"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation group surfaceIds that reference missing surfaces', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'dashboard')],
+        groups: [
+          {
+            id: 'primary',
+            label: 'Primary',
+            placement: 'primary',
+            surfaceIds: ['missing.surface']
+          }
+        ]
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation group "primary" references unknown surface "missing.surface"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation surface featureId references to missing features', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'missing.feature')],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation surface featureIds references to missing features', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'dashboard', ['dashboard', 'missing.feature'])],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
+      )
+    ).toBe(true)
+  })
+
+  it('allows legacy navigation feature aliases when canonical features exist', () => {
+    const result = OrganizationModelSchema.safeParse({
+      ...makeMinimalModel([
+        { id: 'sales', label: 'Sales', enabled: true },
+        makeFeature('sales.crm', '/sales/crm/pipeline'),
+        makeFeature('sales.lead-gen', '/lead-gen/lists')
+      ]),
+      navigation: {
+        defaultSurfaceId: 'crm.pipeline',
+        surfaces: [
+          makeSurface('crm.pipeline', 'crm', ['crm']),
+          makeSurface('lead-gen.lists', 'lead-gen', ['lead-gen'])
+        ],
+        groups: []
+      }
+    })
+
+    expect(result.success).toBe(true)
+  })
 })

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

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import {
+  projectOrganizationSurfaces,
+  validateOrganizationSurfaceProjection
+} from '../surface-projection'
+import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from '../types'
+
+function makeFeature(
+  id: string,
+  overrides: Partial<OrganizationModelFeature> = {}
+): OrganizationModelFeature {
+  return {
+    id,
+    label: id,
+    enabled: true,
+    ...overrides
+  }
+}
+
+function makeSurface(
+  id: string,
+  overrides: Partial<OrganizationModelSurface> = {}
+): OrganizationModelSurface {
+  return {
+    id,
+    label: id,
+    path: `/${id.replaceAll('.', '/')}`,
+    surfaceType: 'page',
+    enabled: true,
+    featureIds: [],
+    entityIds: [],
+    resourceIds: [],
+    capabilityIds: [],
+    ...overrides
+  }
+}
+
+function makeModel(
+  features: OrganizationModelFeature[],
+  surfaces: OrganizationModelSurface[],
+  navigation: Partial<OrganizationModel['navigation']> = {}
+): OrganizationModel {
+  return {
+    ...DEFAULT_ORGANIZATION_MODEL,
+    features,
+    navigation: {
+      surfaces,
+      groups: [],
+      ...navigation
+    }
+  }
+}
+
+describe('projectOrganizationSurfaces', () => {
+  it('projects navigation surfaces into data-only DTOs with inherited flags', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales', { requiresAdmin: true }),
+        makeFeature('sales.crm', { devOnly: true })
+      ],
+      [
+        makeSurface('crm.pipeline', {
+          label: 'Pipeline',
+          path: '/crm/pipeline',
+          surfaceType: 'graph',
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm'],
+          entityIds: ['crm.deal'],
+          resourceIds: ['workflow.crm-sync'],
+          capabilityIds: ['crm.pipeline.manage']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)).toEqual([
+      {
+        id: 'crm.pipeline',
+        label: 'Pipeline',
+        path: '/crm/pipeline',
+        surfaceType: 'graph',
+        featureId: 'sales.crm',
+        featureIds: ['sales.crm'],
+        entityIds: ['crm.deal'],
+        resourceIds: ['workflow.crm-sync'],
+        capabilityIds: ['crm.pipeline.manage'],
+        enabled: true,
+        devOnly: true,
+        requiresAdmin: true
+      }
+    ])
+  })
+
+  it('canonicalizes legacy feature aliases', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales'),
+        makeFeature('sales.crm'),
+        makeFeature('sales.lead-gen'),
+        makeFeature('monitoring'),
+        makeFeature('monitoring.submitted-requests')
+      ],
+      [
+        makeSurface('legacy.sales', {
+          featureId: 'crm',
+          featureIds: ['crm', 'lead-gen', 'submitted-requests']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)[0]).toMatchObject({
+      featureId: 'sales.crm',
+      featureIds: ['sales.crm', 'sales.lead-gen', 'monitoring.submitted-requests']
+    })
+  })
+
+  it('disables projected surfaces when feature lineage is disabled', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales', { enabled: false }),
+        makeFeature('sales.crm')
+      ],
+      [
+        makeSurface('crm.pipeline', {
+          enabled: true,
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)[0].enabled).toBe(false)
+  })
+})
+
+describe('validateOrganizationSurfaceProjection', () => {
+  it('returns issue codes for duplicate and unknown surface references', () => {
+    const model = makeModel(
+      [makeFeature('sales'), makeFeature('sales.crm')],
+      [
+        makeSurface('crm.pipeline', {
+          path: '/crm/pipeline',
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm']
+        }),
+        makeSurface('crm.pipeline', {
+          path: '/crm/pipeline/',
+          featureId: 'missing.primary',
+          featureIds: ['missing.related']
+        })
+      ],
+      {
+        defaultSurfaceId: 'missing.default',
+        groups: [
+          {
+            id: 'primary',
+            label: 'Primary',
+            placement: 'primary',
+            surfaceIds: ['missing.group']
+          }
+        ]
+      }
+    )
+
+    expect(validateOrganizationSurfaceProjection(model).map((issue) => issue.code)).toEqual([
+      'duplicate-surface-id',
+      'duplicate-surface-path',
+      'unknown-surface-feature',
+      'unknown-surface-feature-reference',
+      'unknown-default-surface',
+      'unknown-group-surface'
+    ])
+  })
+})

package/src/organization-model/domains/prospecting.ts

@@ -30,22 +30,95 @@ export const ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
 export type ListBuilderStep = z.infer<typeof ProspectingBuildTemplateStepSchema>
 export type TemplateName = 'localServices' | 'dtcApolloClickup'
 export type StepName = string
-export type CapabilityRegistry = Record<string, string>
 
-export const CAPABILITY_REGISTRY = {
-  'lead-gen.company.source': 'lgn-import-workflow',
-  'lead-gen.company.apollo-import': 'lgn-01c-apollo-import-workflow',
-  'lead-gen.contact.discover': 'lgn-04-email-discovery-workflow',
-  'lead-gen.contact.verify-email': 'lgn-05-email-verification-workflow',
-  'lead-gen.company.website-extract': 'lgn-02-website-extract-workflow',
-  'lead-gen.company.qualify': 'lgn-03-company-qualification-workflow',
-  'lead-gen.company.dtc-subscription-qualify': 'lgn-03b-dtc-subscription-score-workflow',
-  'lead-gen.contact.apollo-decision-maker-enrich': 'lgn-04b-apollo-decision-maker-enrich-workflow',
-  'lead-gen.contact.personalize': 'ist-personalization-workflow',
-  'lead-gen.review.outreach-ready': 'ist-upload-contacts-workflow',
-  'lead-gen.export.list': 'lgn-06-export-list-workflow',
-  'lead-gen.company.cleanup': 'lgn-company-cleanup-workflow'
-} as const satisfies CapabilityRegistry
+export const CapabilitySchema = z.object({
+  id: ModelIdSchema,
+  label: z.string(),
+  description: z.string(),
+  resourceId: ModelIdSchema
+})
+
+export type Capability = z.infer<typeof CapabilitySchema>
+export type CapabilityRegistry = Capability[]
+
+export const CAPABILITY_REGISTRY: CapabilityRegistry = [
+  {
+    id: 'lead-gen.company.source',
+    label: 'Source companies',
+    description: 'Import source companies from a list provider.',
+    resourceId: 'lgn-import-workflow'
+  },
+  {
+    id: 'lead-gen.company.apollo-import',
+    label: 'Import from Apollo',
+    description: 'Pull companies and seed contact data from an Apollo search or list.',
+    resourceId: 'lgn-01c-apollo-import-workflow'
+  },
+  {
+    id: 'lead-gen.contact.discover',
+    label: 'Discover contact emails',
+    description: 'Find email addresses for contacts at qualified companies.',
+    resourceId: 'lgn-04-email-discovery-workflow'
+  },
+  {
+    id: 'lead-gen.contact.verify-email',
+    label: 'Verify emails',
+    description: 'Check email deliverability before outreach.',
+    resourceId: 'lgn-05-email-verification-workflow'
+  },
+  {
+    id: 'lead-gen.company.website-extract',
+    label: 'Extract website signals',
+    description: 'Scrape and analyze company websites for qualification signals.',
+    resourceId: 'lgn-02-website-extract-workflow'
+  },
+  {
+    id: 'lead-gen.company.qualify',
+    label: 'Qualify companies',
+    description: 'Score and filter companies against the ICP rubric.',
+    resourceId: 'lgn-03-company-qualification-workflow'
+  },
+  {
+    id: 'lead-gen.company.dtc-subscription-qualify',
+    label: 'Qualify DTC subscription fit',
+    description: 'Classify subscription potential and consumable-product fit for DTC brands.',
+    resourceId: 'lgn-03b-dtc-subscription-score-workflow'
+  },
+  {
+    id: 'lead-gen.contact.apollo-decision-maker-enrich',
+    label: 'Enrich decision-makers',
+    description: 'Find and enrich qualified contacts at qualified companies via Apollo.',
+    resourceId: 'lgn-04b-apollo-decision-maker-enrich-workflow'
+  },
+  {
+    id: 'lead-gen.contact.personalize',
+    label: 'Personalize outreach',
+    description: 'Generate personalized opening lines for each contact.',
+    resourceId: 'ist-personalization-workflow'
+  },
+  {
+    id: 'lead-gen.review.outreach-ready',
+    label: 'Upload to outreach',
+    description: 'Upload approved contacts to the outreach sequence after QC review.',
+    resourceId: 'ist-upload-contacts-workflow'
+  },
+  {
+    id: 'lead-gen.export.list',
+    label: 'Export lead list',
+    description: 'Export approved leads as a downloadable lead list.',
+    resourceId: 'lgn-06-export-list-workflow'
+  },
+  {
+    id: 'lead-gen.company.cleanup',
+    label: 'Clean up companies',
+    description: 'Remove disqualified or duplicate companies from the list.',
+    resourceId: 'lgn-company-cleanup-workflow'
+  }
+]
+
+export function findCapabilityById(id: string): Capability | undefined {
+  return CAPABILITY_REGISTRY.find((c) => c.id === id)
+}
 
 export const PROSPECTING_STEPS = {
   localServices: {
@@ -234,7 +307,9 @@ function toProspectingLifecycleStage(stage: LeadGenStageCatalogEntry): z.infer<t
   }
 }
 
-function leadGenStagesForEntity(entity: LeadGenStageCatalogEntry['entity']): z.infer<typeof ProspectingLifecycleStageSchema>[] {
+function leadGenStagesForEntity(
+  entity: LeadGenStageCatalogEntry['entity']
+): z.infer<typeof ProspectingLifecycleStageSchema>[] {
   return Object.values(LEAD_GEN_STAGE_CATALOG)
     .filter((stage) => stage.entity === entity)
     .sort((a, b) => a.order - b.order)

package/src/organization-model/domains/sales.ts

@@ -135,6 +135,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[]
 }
 
@@ -251,6 +253,7 @@ export const CRM_PIPELINE_DEFINITION: StatefulPipelineDefinition = {
     {
       stageKey: 'interested',
       label: 'Interested',
+      color: 'blue',
       states: [
         CRM_DISCOVERY_REPLIED_STATE,
         CRM_DISCOVERY_LINK_SENT_STATE,
@@ -262,11 +265,11 @@ export const CRM_PIPELINE_DEFINITION: StatefulPipelineDefinition = {
         CRM_FOLLOWUP_3_SENT_STATE
       ]
     },
-    { stageKey: 'proposal', label: 'Proposal', states: [] },
-    { stageKey: 'closing', label: 'Closing', states: [] },
-    { stageKey: 'closed_won', label: 'Closed Won', states: [] },
-    { stageKey: 'closed_lost', label: 'Closed Lost', states: [] },
-    { stageKey: 'nurturing', label: 'Nurturing', states: [] }
+    { stageKey: 'proposal', label: 'Proposal', color: 'yellow', states: [] },
+    { stageKey: 'closing', label: 'Closing', color: 'orange', states: [] },
+    { stageKey: 'closed_won', label: 'Closed Won', color: 'green', states: [] },
+    { stageKey: 'closed_lost', label: 'Closed Lost', color: 'red', states: [] },
+    { stageKey: 'nurturing', label: 'Nurturing', color: 'grape', states: [] }
   ]
 }