@elevasis/core 0.25.0 → 0.27.0

package/src/organization-model/__tests__/migration-helpers.test.ts

@@ -1,591 +1,362 @@
-import { describe, expect, it } from 'vitest'
-import {
-  getAllPipelines,
-  getAllBuildTemplates,
-  getAllProjectStatuses,
-  getAllProspectingStages,
-  getStagesInPipeline
-} from '../migration-helpers'
-import { resolveOrganizationModel } from '../resolve'
-import type { DeepPartial, OrganizationModel } from '../types'
-
-// ---------------------------------------------------------------------------
-// Fixtures — all authored via system.content per Phase 4 schema (D1, D3, D8).
-// No compound-domain paths (model.sales.*, model.prospecting.*, model.projects.*).
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal model with a pipeline + stages in sales.crm content.
- * Matches what the Wave 2 canonical OM authors for the Elevasis workspace.
- */
-function modelWithPipeline(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      'sales.crm': {
-        id: 'sales.crm',
-        order: 70,
-        label: 'CRM',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/crm',
-        content: {
-          'default-pipeline': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Default Deal Pipeline',
-            data: { entityId: 'crm.deal' }
-          },
-          'stage-open': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Open',
-            parentContentId: 'default-pipeline',
-            data: { order: 10, semanticClass: 'open', surfaceIds: [], resourceIds: [] }
-          },
-          'stage-active': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Active',
-            parentContentId: 'default-pipeline',
-            data: { order: 20, semanticClass: 'active', surfaceIds: [], resourceIds: [] }
-          },
-          'stage-closed-won': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Closed Won',
-            parentContentId: 'default-pipeline',
-            data: { order: 30, semanticClass: 'closed_won', surfaceIds: [], resourceIds: [] }
-          }
-        }
-      }
-    }
-  } as DeepPartial<OrganizationModel>)
-}
-
-/**
- * Minimal model with two pipelines on different systems.
- */
-function modelWithTwoPipelines(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      'sales.crm': {
-        id: 'sales.crm',
-        order: 70,
-        label: 'CRM',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/crm',
-        content: {
-          'crm-pipeline': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'CRM Pipeline',
-            data: { entityId: 'crm.deal' }
-          },
-          'crm-stage-1': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Lead',
-            parentContentId: 'crm-pipeline',
-            data: { order: 10, semanticClass: 'open', surfaceIds: [], resourceIds: [] }
-          }
-        }
-      },
-      projects: {
-        id: 'projects',
-        order: 90,
-        label: 'Projects',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/projects',
-        content: {
-          'projects-pipeline': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Projects Pipeline',
-            data: { entityId: 'delivery.project' }
-          },
-          'projects-stage-1': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Active',
-            parentContentId: 'projects-pipeline',
-            data: { order: 10, semanticClass: 'active', surfaceIds: [], resourceIds: [] }
-          }
-        }
-      }
-    }
-  } as DeepPartial<OrganizationModel>)
-}
-
-/**
- * Minimal model with a build template + steps in sales.lead-gen content.
- */
-function modelWithBuildTemplate(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      'sales.lead-gen': {
-        id: 'sales.lead-gen',
-        order: 80,
-        label: 'Lead Gen',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/lead-gen',
-        content: {
-          'local-services-template': {
-            kind: 'schema',
-            type: 'template',
-            label: 'Local Services',
-            data: { color: 'blue' }
-          },
-          'step-source': {
-            kind: 'schema',
-            type: 'template-step',
-            label: 'Source Companies',
-            parentContentId: 'local-services-template',
-            data: {
-              stageKey: 'populated',
-              actionKey: 'lead-gen.company.source',
-              primaryEntity: 'company',
-              outputs: ['company'],
-              dependencyMode: 'per-record-eligibility',
-              defaultBatchSize: 100,
-              maxBatchSize: 500
-            }
-          },
-          'step-qualify': {
-            kind: 'schema',
-            type: 'template-step',
-            label: 'Qualify Companies',
-            parentContentId: 'local-services-template',
-            data: {
-              stageKey: 'qualified',
-              actionKey: 'lead-gen.company.qualify',
-              primaryEntity: 'company',
-              outputs: ['company'],
-              dependencyMode: 'per-record-eligibility',
-              defaultBatchSize: 100,
-              maxBatchSize: 500
-            }
-          }
-        }
-      }
-    }
-  } as DeepPartial<OrganizationModel>)
-}
-
-/**
- * Minimal model with prospecting stages (company + contact) in lead-gen content.
- * Prospecting stages are distinguished by data.entityKind.
- */
-function modelWithProspectingStages(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      'sales.lead-gen': {
-        id: 'sales.lead-gen',
-        order: 80,
-        label: 'Lead Gen',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/lead-gen',
-        content: {
-          'company-stage-populated': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Populated',
-            data: { order: 10, entityKind: 'company' }
-          },
-          'company-stage-qualified': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Qualified',
-            data: { order: 20, entityKind: 'company' }
-          },
-          'contact-stage-discovered': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Discovered',
-            data: { order: 10, entityKind: 'contact' }
-          }
-        }
-      }
-    }
-  } as DeepPartial<OrganizationModel>)
-}
-
-/**
- * Minimal model with project statuses (status-flow + status nodes) in projects content.
- */
-function modelWithProjectStatuses(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      projects: {
-        id: 'projects',
-        order: 90,
-        label: 'Projects',
-        enabled: true,
-        lifecycle: 'active',
-        path: '/projects',
-        content: {
-          'project-status-flow': {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Project Statuses',
-            data: { appliesTo: 'project' }
-          },
-          'project-status-active': {
-            kind: 'schema',
-            type: 'status',
-            label: 'Active',
-            parentContentId: 'project-status-flow',
-            data: { order: 10 }
-          },
-          'project-status-completed': {
-            kind: 'schema',
-            type: 'status',
-            label: 'Completed',
-            parentContentId: 'project-status-flow',
-            data: { order: 20 }
-          },
-          'milestone-status-flow': {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Milestone Statuses',
-            data: { appliesTo: 'milestone' }
-          },
-          'milestone-status-upcoming': {
-            kind: 'schema',
-            type: 'status',
-            label: 'Upcoming',
-            parentContentId: 'milestone-status-flow',
-            data: { order: 10 }
-          },
-          'task-status-flow': {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Task Statuses',
-            data: { appliesTo: 'task' }
-          },
-          'task-status-planned': {
-            kind: 'schema',
-            type: 'status',
-            label: 'Planned',
-            parentContentId: 'task-status-flow',
-            data: { order: 10 }
-          },
-          'task-status-in-progress': {
-            kind: 'schema',
-            type: 'status',
-            label: 'In Progress',
-            parentContentId: 'task-status-flow',
-            data: { order: 20 }
-          }
-        }
-      }
-    }
-  } as DeepPartial<OrganizationModel>)
-}
-
-// ---------------------------------------------------------------------------
-// getAllPipelines
-// ---------------------------------------------------------------------------
-describe('getAllPipelines', () => {
-  it('returns all pipelines from a model with system.content pipeline nodes', () => {
-    const model = modelWithPipeline()
-    const result = getAllPipelines(model)
-
-    expect(result.length).toBeGreaterThanOrEqual(1)
-    for (const entry of result) {
-      expect(entry).toHaveProperty('systemPath')
-      expect(entry).toHaveProperty('pipeline')
-      expect(entry.pipeline).toHaveProperty('id')
-      expect(entry.pipeline).toHaveProperty('stages')
-    }
-  })
-
-  it('tags each pipeline with the owning system path', () => {
-    const model = modelWithPipeline()
-    const result = getAllPipelines(model)
-
-    const pipelineEntry = result.find((e) => e.pipeline.id === 'default-pipeline')
-    expect(pipelineEntry).toBeDefined()
-    expect(pipelineEntry?.systemPath).toBe('sales.crm')
-  })
-
-  it('reconstructs pipeline.stages from sibling stage content nodes', () => {
-    const model = modelWithPipeline()
-    const result = getAllPipelines(model)
-
-    const entry = result.find((e) => e.pipeline.id === 'default-pipeline')
-    expect(entry).toBeDefined()
-    expect(entry?.pipeline.stages.length).toBe(3)
-  })
-
-  it('returns stages sorted ascending by order', () => {
-    const model = modelWithPipeline()
-    const [entry] = getAllPipelines(model)
-    expect(entry).toBeDefined()
-
-    const stages = entry!.pipeline.stages
-    for (let i = 1; i < stages.length; i++) {
-      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
-    }
-  })
-
-  it('collects pipelines from multiple systems', () => {
-    const model = modelWithTwoPipelines()
-    const result = getAllPipelines(model)
-
-    const ids = result.map((e) => e.pipeline.id).sort()
-    expect(ids).toContain('crm-pipeline')
-    expect(ids).toContain('projects-pipeline')
-  })
-
-  it('returns empty array when no systems have pipeline content nodes', () => {
-    const model = resolveOrganizationModel()
-    expect(getAllPipelines(model)).toEqual([])
-  })
-
-  it('each stage has required shape fields', () => {
-    const model = modelWithPipeline()
-    const [entry] = getAllPipelines(model)
-
-    for (const stage of entry!.pipeline.stages) {
-      expect(stage).toHaveProperty('id')
-      expect(stage).toHaveProperty('label')
-      expect(stage).toHaveProperty('order')
-      expect(stage).toHaveProperty('semanticClass')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getStagesInPipeline
-// ---------------------------------------------------------------------------
-describe('getStagesInPipeline', () => {
-  it('returns stages for a named pipeline sorted by order', () => {
-    const model = modelWithPipeline()
-    const stages = getStagesInPipeline(model, 'sales.crm', 'default-pipeline')
-
-    expect(stages.length).toBe(3)
-    for (let i = 1; i < stages.length; i++) {
-      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
-    }
-  })
-
-  it('returns empty array for an unknown system path', () => {
-    const model = modelWithPipeline()
-    expect(getStagesInPipeline(model, 'nonexistent.system', 'default-pipeline')).toEqual([])
-  })
-
-  it('returns empty array for an unknown pipeline id', () => {
-    const model = modelWithPipeline()
-    expect(getStagesInPipeline(model, 'sales.crm', 'nonexistent-pipeline')).toEqual([])
-  })
-
-  it('does not include pipeline nodes themselves — only stage nodes', () => {
-    const model = modelWithPipeline()
-    const stages = getStagesInPipeline(model, 'sales.crm', 'default-pipeline')
-
-    // Every result should be a stage, not a pipeline
-    expect(stages.every((s) => 'semanticClass' in s)).toBe(true)
-  })
-
-  it('only returns stages belonging to the specified pipeline via parentContentId', () => {
-    const model = modelWithTwoPipelines()
-
-    const crmStages = getStagesInPipeline(model, 'sales.crm', 'crm-pipeline')
-    expect(crmStages.map((s) => s.id)).toContain('crm-stage-1')
-
-    const projectsStages = getStagesInPipeline(model, 'projects', 'projects-pipeline')
-    expect(projectsStages.map((s) => s.id)).toContain('projects-stage-1')
-
-    // CRM stages should not appear in project pipeline results
-    expect(projectsStages.map((s) => s.id)).not.toContain('crm-stage-1')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getAllBuildTemplates
-// ---------------------------------------------------------------------------
-describe('getAllBuildTemplates', () => {
-  it('returns all build templates from content nodes', () => {
-    const model = modelWithBuildTemplate()
-    const result = getAllBuildTemplates(model)
-
-    expect(result.length).toBeGreaterThanOrEqual(1)
-    for (const template of result) {
-      expect(template).toHaveProperty('id')
-      expect(template).toHaveProperty('steps')
-      expect(template.steps.length).toBeGreaterThanOrEqual(1)
-    }
-  })
-
-  it('reconstructs template steps from sibling template-step content nodes', () => {
-    const model = modelWithBuildTemplate()
-    const result = getAllBuildTemplates(model)
-
-    const template = result.find((t) => t.id === 'local-services-template')
-    expect(template).toBeDefined()
-    expect(template?.steps.length).toBe(2)
-  })
-
-  it('returns empty array when no systems have template content nodes', () => {
-    const model = resolveOrganizationModel()
-    expect(getAllBuildTemplates(model)).toEqual([])
-  })
-
-  it('each template has a non-empty label', () => {
-    const model = modelWithBuildTemplate()
-    const result = getAllBuildTemplates(model)
-
-    for (const template of result) {
-      expect(template.label.length).toBeGreaterThan(0)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getAllProspectingStages
-// ---------------------------------------------------------------------------
-describe('getAllProspectingStages', () => {
-  it('returns company stages from content nodes with data.entityKind === "company"', () => {
-    const model = modelWithProspectingStages()
-    const stages = getAllProspectingStages(model, 'company')
-
-    expect(stages.length).toBe(2)
-    expect(stages.map((s) => s.id).sort()).toEqual(['company-stage-populated', 'company-stage-qualified'].sort())
-  })
-
-  it('returns contact stages from content nodes with data.entityKind === "contact"', () => {
-    const model = modelWithProspectingStages()
-    const stages = getAllProspectingStages(model, 'contact')
-
-    expect(stages.length).toBe(1)
-    expect(stages[0]?.id).toBe('contact-stage-discovered')
-  })
-
-  it('returns company and contact stage sets from distinct data.entityKind values', () => {
-    const model = modelWithProspectingStages()
-    const companyIds = new Set(getAllProspectingStages(model, 'company').map((s) => s.id))
-    const contactIds = new Set(getAllProspectingStages(model, 'contact').map((s) => s.id))
-
-    expect(companyIds.size).toBeGreaterThan(0)
-    expect(contactIds.size).toBeGreaterThan(0)
-
-    // No overlap — distinct entity kinds
-    for (const id of contactIds) {
-      expect(companyIds.has(id)).toBe(false)
-    }
-  })
-
-  it('returns stages sorted ascending by order', () => {
-    const model = modelWithProspectingStages()
-    const stages = getAllProspectingStages(model, 'company')
-
-    for (let i = 1; i < stages.length; i++) {
-      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
-    }
-  })
-
-  it('returns empty array when no systems have prospecting stage content nodes', () => {
-    const model = resolveOrganizationModel()
-    expect(getAllProspectingStages(model, 'company')).toEqual([])
-    expect(getAllProspectingStages(model, 'contact')).toEqual([])
-  })
-
-  it('each stage has required shape fields', () => {
-    const model = modelWithProspectingStages()
-    const stages = getAllProspectingStages(model, 'company')
-
-    for (const stage of stages) {
-      expect(stage).toHaveProperty('id')
-      expect(stage).toHaveProperty('label')
-      expect(stage).toHaveProperty('order')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getAllProjectStatuses
-// ---------------------------------------------------------------------------
-describe('getAllProjectStatuses', () => {
-  it('returns project statuses from status-flow + status content nodes', () => {
-    const model = modelWithProjectStatuses()
-    const statuses = getAllProjectStatuses(model, 'project')
-
-    expect(statuses.length).toBe(2)
-    expect(statuses.map((s) => s.id).sort()).toEqual(['project-status-active', 'project-status-completed'].sort())
-  })
-
-  it('returns milestone statuses from milestone status-flow', () => {
-    const model = modelWithProjectStatuses()
-    const statuses = getAllProjectStatuses(model, 'milestone')
-
-    expect(statuses.length).toBe(1)
-    expect(statuses[0]?.id).toBe('milestone-status-upcoming')
-  })
-
-  it('returns task statuses from task status-flow', () => {
-    const model = modelWithProjectStatuses()
-    const statuses = getAllProjectStatuses(model, 'task')
-
-    expect(statuses.length).toBe(2)
-    expect(statuses.map((s) => s.id).sort()).toEqual(['task-status-in-progress', 'task-status-planned'].sort())
-  })
-
-  it('returns statuses sorted ascending by order', () => {
-    const model = modelWithProjectStatuses()
-    const statuses = getAllProjectStatuses(model, 'project')
-
-    for (let i = 1; i < statuses.length; i++) {
-      expect(statuses[i]!.order).toBeGreaterThanOrEqual(statuses[i - 1]!.order)
-    }
-  })
-
-  it('three entity-types return distinct status sets', () => {
-    const model = modelWithProjectStatuses()
-    const projectIds = new Set(getAllProjectStatuses(model, 'project').map((s) => s.id))
-    const milestoneIds = new Set(getAllProjectStatuses(model, 'milestone').map((s) => s.id))
-    const taskIds = new Set(getAllProjectStatuses(model, 'task').map((s) => s.id))
-
-    expect(projectIds.size).toBeGreaterThan(0)
-    expect(milestoneIds.size).toBeGreaterThan(0)
-    expect(taskIds.size).toBeGreaterThan(0)
-
-    // Cross-check: no overlap between project/task
-    for (const id of taskIds) {
-      expect(projectIds.has(id)).toBe(false)
-    }
-  })
-
-  it('each status has required shape fields', () => {
-    const model = modelWithProjectStatuses()
-
-    for (const kind of ['project', 'milestone', 'task'] as const) {
-      const statuses = getAllProjectStatuses(model, kind)
-      for (const status of statuses) {
-        expect(status).toHaveProperty('id')
-        expect(status).toHaveProperty('label')
-        expect(status).toHaveProperty('order')
-      }
-    }
-  })
-
-  it('returns empty array when no systems have status-flow content nodes', () => {
-    const model = resolveOrganizationModel()
-    expect(getAllProjectStatuses(model, 'project')).toEqual([])
-    expect(getAllProjectStatuses(model, 'milestone')).toEqual([])
-    expect(getAllProjectStatuses(model, 'task')).toEqual([])
-  })
-
-  it('only collects status nodes belonging to the correct status-flow via parentContentId', () => {
-    const model = modelWithProjectStatuses()
-
-    // Task statuses should not appear in project results
-    const projectStatuses = getAllProjectStatuses(model, 'project')
-    const projectStatusIds = new Set(projectStatuses.map((s) => s.id))
-    expect(projectStatusIds.has('task-status-planned')).toBe(false)
-    expect(projectStatusIds.has('task-status-in-progress')).toBe(false)
-  })
-})
+import { describe, expect, it } from 'vitest'
+import {
+  getAllBuildTemplates,
+  getAllPipelines,
+  getAllProjectStatuses,
+  getAllProspectingStages,
+  getLeadGenStageCatalog,
+  getStagesInPipeline
+} from '../migration-helpers'
+import { resolveOrganizationModel } from '../resolve'
+import type { DeepPartial, OrganizationModel } from '../types'
+
+function resolveModel(partial: DeepPartial<OrganizationModel>): OrganizationModel {
+  return resolveOrganizationModel(partial)
+}
+
+function modelWithPipelines(): OrganizationModel {
+  return resolveModel({
+    systems: {
+      'sales.crm': {
+        id: 'sales.crm',
+        order: 70,
+        label: 'CRM',
+        lifecycle: 'active',
+        path: '/crm',
+        ontology: {
+          objectTypes: {
+            'sales.crm:object/deal': {
+              id: 'sales.crm:object/deal',
+              label: 'Deal',
+              ownerSystemId: 'sales.crm'
+            }
+          },
+          catalogTypes: {
+            'sales.crm:catalog/default-pipeline': {
+              id: 'sales.crm:catalog/default-pipeline',
+              label: 'Default Deal Pipeline',
+              kind: 'pipeline',
+              appliesTo: 'sales.crm:object/deal',
+              entries: {
+                open: { label: 'Open', order: 10, semanticClass: 'open' },
+                active: { label: 'Active', order: 20, semanticClass: 'active' },
+                'closed-won': { label: 'Closed Won', order: 30, semanticClass: 'closed_won' }
+              }
+            }
+          }
+        }
+      },
+      projects: {
+        id: 'projects',
+        order: 90,
+        label: 'Projects',
+        lifecycle: 'active',
+        path: '/projects',
+        ontology: {
+          objectTypes: {
+            'projects:object/project': {
+              id: 'projects:object/project',
+              label: 'Project',
+              ownerSystemId: 'projects'
+            }
+          },
+          catalogTypes: {
+            'projects:catalog/projects-pipeline': {
+              id: 'projects:catalog/projects-pipeline',
+              label: 'Projects Pipeline',
+              kind: 'pipeline',
+              appliesTo: 'projects:object/project',
+              entries: {
+                lead: { label: 'Lead', order: 10, semanticClass: 'open' }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+function modelWithBuildTemplate(): OrganizationModel {
+  return resolveModel({
+    systems: {
+      'sales.lead-gen': {
+        id: 'sales.lead-gen',
+        order: 80,
+        label: 'Lead Gen',
+        lifecycle: 'active',
+        path: '/lead-gen',
+        ontology: {
+          objectTypes: {
+            'sales.lead-gen:object/list': {
+              id: 'sales.lead-gen:object/list',
+              label: 'Lead List',
+              ownerSystemId: 'sales.lead-gen'
+            }
+          },
+          catalogTypes: {
+            'sales.lead-gen:catalog/build-template': {
+              id: 'sales.lead-gen:catalog/build-template',
+              label: 'Build Templates',
+              kind: 'template',
+              appliesTo: 'sales.lead-gen:object/list',
+              entries: {
+                'local-services': {
+                  label: 'Local Services',
+                  color: 'blue',
+                  stepCatalog: 'sales.lead-gen:catalog/template-step.local-services'
+                }
+              }
+            },
+            'sales.lead-gen:catalog/template-step.local-services': {
+              id: 'sales.lead-gen:catalog/template-step.local-services',
+              label: 'Local Services Steps',
+              kind: 'template-step',
+              appliesTo: 'sales.lead-gen:object/list',
+              entries: {
+                'source-companies': {
+                  label: 'Source Companies',
+                  order: 10,
+                  primaryEntity: 'company',
+                  outputs: ['company'],
+                  stageKey: 'populated',
+                  dependencyMode: 'per-record-eligibility',
+                  actionKey: 'lead-gen.company.source',
+                  defaultBatchSize: 100,
+                  maxBatchSize: 500
+                },
+                'qualify-companies': {
+                  label: 'Qualify Companies',
+                  order: 20,
+                  primaryEntity: 'company',
+                  outputs: ['company'],
+                  stageKey: 'qualified',
+                  dependsOn: ['source-companies'],
+                  dependencyMode: 'per-record-eligibility',
+                  actionKey: 'lead-gen.company.qualify',
+                  defaultBatchSize: 100,
+                  maxBatchSize: 500
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+function modelWithProspectingStages(): OrganizationModel {
+  return resolveModel({
+    systems: {
+      'sales.lead-gen': {
+        id: 'sales.lead-gen',
+        order: 80,
+        label: 'Lead Gen',
+        lifecycle: 'active',
+        path: '/lead-gen',
+        ontology: {
+          objectTypes: {
+            'sales.lead-gen:object/company': {
+              id: 'sales.lead-gen:object/company',
+              label: 'Lead Company',
+              ownerSystemId: 'sales.lead-gen'
+            },
+            'sales.lead-gen:object/contact': {
+              id: 'sales.lead-gen:object/contact',
+              label: 'Lead Contact',
+              ownerSystemId: 'sales.lead-gen'
+            }
+          },
+          catalogTypes: {
+            'sales.lead-gen:catalog/company-stage': {
+              id: 'sales.lead-gen:catalog/company-stage',
+              label: 'Company Stages',
+              kind: 'stage',
+              appliesTo: 'sales.lead-gen:object/company',
+              entries: {
+                populated: { label: 'Populated', description: 'Companies imported.', order: 10 },
+                qualified: { label: 'Qualified', description: 'Companies qualified.', order: 20 }
+              }
+            },
+            'sales.lead-gen:catalog/contact-stage': {
+              id: 'sales.lead-gen:catalog/contact-stage',
+              label: 'Contact Stages',
+              kind: 'stage',
+              appliesTo: 'sales.lead-gen:object/contact',
+              entries: {
+                discovered: { label: 'Discovered', description: 'Contacts found.', order: 10 },
+                uploaded: {
+                  label: 'Uploaded',
+                  description: 'Contacts exported.',
+                  order: 40,
+                  additionalEntities: ['company'],
+                  recordEntity: 'company',
+                  recordStageKey: 'uploaded'
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+function modelWithProjectStatuses(): OrganizationModel {
+  return resolveModel({
+    systems: {
+      projects: {
+        id: 'projects',
+        order: 90,
+        label: 'Projects',
+        lifecycle: 'active',
+        path: '/projects',
+        ontology: {
+          objectTypes: {
+            'projects:object/project': { id: 'projects:object/project', label: 'Project', ownerSystemId: 'projects' },
+            'projects:object/milestone': {
+              id: 'projects:object/milestone',
+              label: 'Milestone',
+              ownerSystemId: 'projects'
+            },
+            'projects:object/task': { id: 'projects:object/task', label: 'Task', ownerSystemId: 'projects' }
+          },
+          catalogTypes: {
+            'projects:catalog/project-status': {
+              id: 'projects:catalog/project-status',
+              label: 'Project Statuses',
+              kind: 'status-flow',
+              appliesTo: 'projects:object/project',
+              entries: {
+                active: { label: 'Active', order: 10 },
+                completed: { label: 'Completed', order: 20 }
+              }
+            },
+            'projects:catalog/milestone-status': {
+              id: 'projects:catalog/milestone-status',
+              label: 'Milestone Statuses',
+              kind: 'status-flow',
+              appliesTo: 'projects:object/milestone',
+              entries: {
+                upcoming: { label: 'Upcoming', order: 10 }
+              }
+            },
+            'projects:catalog/task-status': {
+              id: 'projects:catalog/task-status',
+              label: 'Task Statuses',
+              kind: 'status-flow',
+              appliesTo: 'projects:object/task',
+              entries: {
+                planned: { label: 'Planned', order: 10 },
+                'in-progress': { label: 'In Progress', order: 20 }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+describe('getAllPipelines', () => {
+  it('returns all ontology-authored pipelines with owning system paths', () => {
+    const result = getAllPipelines(modelWithPipelines())
+
+    expect(result.map((entry) => [entry.systemPath, entry.pipeline.id])).toEqual([
+      ['projects', 'projects-pipeline'],
+      ['sales.crm', 'default-pipeline']
+    ])
+  })
+
+  it('reconstructs pipeline stages from catalog entries sorted by order', () => {
+    const pipeline = getAllPipelines(modelWithPipelines()).find((entry) => entry.pipeline.id === 'default-pipeline')
+
+    expect(pipeline?.pipeline.entityId).toBe('deal')
+    expect(pipeline?.pipeline.stages.map((stage) => stage.id)).toEqual(['open', 'active', 'closed-won'])
+  })
+
+  it('returns empty arrays when no ontology pipeline catalog exists', () => {
+    expect(getAllPipelines(resolveOrganizationModel())).toEqual([])
+  })
+})
+
+describe('getStagesInPipeline', () => {
+  it('returns stages for a named ontology pipeline catalog', () => {
+    expect(getStagesInPipeline(modelWithPipelines(), 'sales.crm', 'default-pipeline').map((stage) => stage.id)).toEqual([
+      'open',
+      'active',
+      'closed-won'
+    ])
+  })
+
+  it('returns empty arrays for unknown system paths and pipeline ids', () => {
+    const model = modelWithPipelines()
+
+    expect(getStagesInPipeline(model, 'missing', 'default-pipeline')).toEqual([])
+    expect(getStagesInPipeline(model, 'sales.crm', 'missing')).toEqual([])
+  })
+})
+
+describe('getAllBuildTemplates', () => {
+  it('returns templates with steps from referenced ontology step catalogs', () => {
+    const [template] = getAllBuildTemplates(modelWithBuildTemplate())
+
+    expect(template).toMatchObject({ id: 'local-services', label: 'Local Services', color: 'blue' })
+    expect(template?.steps.map((step) => step.id)).toEqual(['source-companies', 'qualify-companies'])
+  })
+
+  it('returns an empty array when no template catalog exists', () => {
+    expect(getAllBuildTemplates(resolveOrganizationModel())).toEqual([])
+  })
+})
+
+describe('getAllProspectingStages', () => {
+  it('returns company and contact stages from ontology stage catalogs', () => {
+    const model = modelWithProspectingStages()
+
+    expect(getAllProspectingStages(model, 'company').map((stage) => stage.id)).toEqual(['populated', 'qualified'])
+    expect(getAllProspectingStages(model, 'contact').map((stage) => stage.id)).toEqual(['discovered', 'uploaded'])
+  })
+
+  it('returns empty arrays when no matching ontology stage catalog exists', () => {
+    const model = resolveOrganizationModel()
+
+    expect(getAllProspectingStages(model, 'company')).toEqual([])
+    expect(getAllProspectingStages(model, 'contact')).toEqual([])
+  })
+})
+
+describe('getLeadGenStageCatalog', () => {
+  it('returns the combined lead-gen stage catalog shape from ontology', () => {
+    const result = getLeadGenStageCatalog(modelWithProspectingStages())
+
+    expect(result.populated).toMatchObject({ key: 'populated', entity: 'company', order: 10 })
+    expect(result.discovered).toMatchObject({ key: 'discovered', entity: 'contact', order: 10 })
+    expect(result.uploaded).toMatchObject({
+      key: 'uploaded',
+      entity: 'contact',
+      additionalEntities: ['company'],
+      recordEntity: 'company',
+      recordStageKey: 'uploaded'
+    })
+  })
+})
+
+describe('getAllProjectStatuses', () => {
+  it('returns project, milestone, and task statuses from ontology status-flow catalogs', () => {
+    const model = modelWithProjectStatuses()
+
+    expect(getAllProjectStatuses(model, 'project').map((status) => status.id)).toEqual(['active', 'completed'])
+    expect(getAllProjectStatuses(model, 'milestone').map((status) => status.id)).toEqual(['upcoming'])
+    expect(getAllProjectStatuses(model, 'task').map((status) => status.id)).toEqual(['planned', 'in-progress'])
+  })
+
+  it('returns empty arrays when no matching ontology status-flow catalog exists', () => {
+    const model = resolveOrganizationModel()
+
+    expect(getAllProjectStatuses(model, 'project')).toEqual([])
+    expect(getAllProjectStatuses(model, 'milestone')).toEqual([])
+    expect(getAllProjectStatuses(model, 'task')).toEqual([])
+  })
+})