@elevasis/core 0.23.0 → 0.24.1

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

@@ -1,591 +1,591 @@
-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 {
+  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)
+  })
+})