@elevasis/core 0.21.0 → 0.23.0

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

@@ -0,0 +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)
+  })
+})

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

@@ -1,8 +1,17 @@
 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 { LEAD_GEN_STAGE_CATALOG } from '../catalogs/lead-gen'
+import { DEFAULT_ORGANIZATION_MODEL_ACTIONS } from '../domains/actions'
+import { ACTION_REGISTRY, PROSPECTING_STEPS } from '../domains/prospecting'
 
-const EXPECTED_CAPABILITY_RESOURCE_BY_ID: Record<string, string> = {
+// Phase 4 cut: DEFAULT_ORGANIZATION_MODEL_PROSPECTING was removed — prospecting
+// lifecycle stages and build templates now live in system.content as (schema:stage)
+// and (schema:template) / (schema:template-step) content nodes on sales.lead-gen.
+// Tests that depended on DEFAULT_ORGANIZATION_MODEL_PROSPECTING.companyStages,
+// .contactStages, and .buildTemplates are skipped below with a clear reason.
+// They should be re-enabled in Wave 5 once content-node graph projection is active
+// and the helpers return the expected shapes from system.content.
+
+const EXPECTED_ACTION_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.company.apify-crawl': 'lgn-02a-apify-website-crawl-workflow',
@@ -54,41 +63,41 @@ describe('prospecting organization-model SSOT', () => {
     }
   })
 
-  it('uses registered capabilities for every prospecting step', () => {
-    const capabilityKeys = new Set(CAPABILITY_REGISTRY.map((c) => c.id))
+  it('uses registered actions for every prospecting step', () => {
+    const actionKeys = new Set(ACTION_REGISTRY.map((c) => c.id))
 
     for (const templateSteps of Object.values(PROSPECTING_STEPS)) {
       for (const step of Object.values(templateSteps)) {
-        expect(capabilityKeys.has(step.capabilityKey), step.id).toBe(true)
+        expect(actionKeys.has(step.actionKey), step.id).toBe(true)
       }
     }
   })
 
-  it('derives prospecting lifecycle stages from the stage catalog by entity', () => {
-    const expectedCompanyStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'company' || stage.additionalEntities?.includes('company'))
-      .sort((a, b) => a.order - b.order)
-      .map(({ key, label, order }) => ({ id: key, label, order }))
-
-    const expectedContactStages = Object.values(LEAD_GEN_STAGE_CATALOG)
-      .filter((stage) => stage.entity === 'contact' || stage.additionalEntities?.includes('contact'))
-      .sort((a, b) => a.order - b.order)
-      .map(({ key, label, order }) => ({ id: key, label, order }))
-
-    expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.companyStages).toEqual(expectedCompanyStages)
-    expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.contactStages).toEqual(expectedContactStages)
+  // Phase 4 (D3): DEFAULT_ORGANIZATION_MODEL_PROSPECTING.companyStages and
+  // .contactStages were removed — lifecycle stages now live in system.content.
+  // Use getAllProspectingStages(model, 'company' | 'contact') from migration-helpers.
+  it.skip('derives prospecting lifecycle stages from the stage catalog by entity (deferred — Phase 4: use getAllProspectingStages())', () => {
+    // Previously: expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.companyStages).toEqual(...)
+    // Re-enable when the canonical OM authors stage content nodes and the test
+    // verifies getAllProspectingStages() returns the expected catalog-derived set.
   })
 
-  it('build templates reference PROSPECTING_STEPS entries', () => {
-    const [localServices, dtcApolloClickup] = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates
+  // Phase 4 (D8): DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates removed.
+  // Build templates now live in system.content as (schema:template) + (schema:template-step).
+  // Use getAllBuildTemplates(model) from migration-helpers.
+  it.skip('build templates reference PROSPECTING_STEPS entries (deferred — Phase 4: use getAllBuildTemplates())', () => {
+    // Previously: expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates).toEqual(...)
+    // Re-enable when the canonical OM authors template content nodes and the test
+    // verifies getAllBuildTemplates() returns the expected template/step shapes.
+  })
 
-    expect(localServices?.steps).toEqual(Object.values(PROSPECTING_STEPS.localServices))
-    expect(dtcApolloClickup?.steps).toEqual(Object.values(PROSPECTING_STEPS.dtcApolloClickup))
+  it('covers all known lead-gen action registry entries', () => {
+    expect(ACTION_REGISTRY).toHaveLength(13)
+    const actualResourceById = Object.fromEntries(ACTION_REGISTRY.map((c) => [c.id, c.resourceId]))
+    expect(actualResourceById).toEqual(EXPECTED_ACTION_RESOURCE_BY_ID)
   })
 
-  it('covers all known lead-gen capability registry entries', () => {
-    expect(CAPABILITY_REGISTRY).toHaveLength(13)
-    const actualResourceById = Object.fromEntries(CAPABILITY_REGISTRY.map((c) => [c.id, c.resourceId]))
-    expect(actualResourceById).toEqual(EXPECTED_CAPABILITY_RESOURCE_BY_ID)
+  it('bridges the legacy prospecting action registry from the top-level actions domain', () => {
+    expect(ACTION_REGISTRY).toEqual(Object.values(DEFAULT_ORGANIZATION_MODEL_ACTIONS))
   })
 })