@elevasis/core 0.26.0 → 0.28.0

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

@@ -1,96 +1,109 @@
-import { z } from 'zod'
-import { ResourceIdSchema } from './resources'
-import { ModelIdSchema } from './shared'
-import { SystemIdSchema } from './systems'
-
-// ---------------------------------------------------------------------------
-// Role schema - one entry per distinct role in the organization's chart.
-// Inspired by the EOS Accountability Chart but uses plain-language field names
-// throughout. No EOS jargon: "title" (not seatTitle), "responsibilities"
-// (not accountabilities), "reportsToId", "heldBy".
-//
-// Cross-reference enforcement lives in `OrganizationModelSchema.superRefine()`:
-// `reportsToId` must resolve to another Role, `responsibleFor` entries must
-// resolve to Systems, and agent holders must resolve to Agent Resources.
-// Role hierarchy cycle detection is also enforced at the model level.
-// ---------------------------------------------------------------------------
-
-export const RoleIdSchema = ModelIdSchema
-
-export const HumanRoleHolderSchema = z.object({
-  kind: z.literal('human'),
-  userId: z.string().trim().min(1).max(200)
-})
-
-export const AgentRoleHolderSchema = z.object({
-  kind: z.literal('agent'),
-  agentId: ResourceIdSchema.meta({ ref: 'resource' })
-})
-
-export const TeamRoleHolderSchema = z.object({
-  kind: z.literal('team'),
-  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
-})
-
-export const RoleHolderSchema = z.discriminatedUnion('kind', [
-  HumanRoleHolderSchema,
-  AgentRoleHolderSchema,
-  TeamRoleHolderSchema
-])
-
-export const RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)])
-
-export const RoleSchema = z.object({
-  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
-  id: RoleIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
-  title: z.string().trim().min(1).max(200),
-  /**
-   * List of responsibilities this role owns - plain-language descriptions of
-   * what the person in this role is accountable for delivering.
-   * Defaults to empty array so minimal role definitions stay concise.
-   */
-  responsibilities: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Optional: ID of another role this role reports to.
-   * When present, must reference another `roles[].id` in the same organization.
-   */
-  reportsToId: RoleIdSchema.meta({ ref: 'role' }).optional(),
-  /**
-   * Optional: human, agent, or team holder currently filling this role.
-   * Agent holders reference OM Resource IDs and are validated at the model level.
-   */
-  heldBy: RoleHoldersSchema.optional(),
-  /**
-   * Optional Systems this role is accountable for.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  responsibleFor: z.array(SystemIdSchema.meta({ ref: 'system' })).optional()
-})
-
-// ---------------------------------------------------------------------------
-// Roles domain schema - a collection of roles.
-// ---------------------------------------------------------------------------
-
-export const RolesDomainSchema = z
-  .record(z.string(), RoleSchema)
-  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-    message: 'Each role entry id must match its map key'
-  })
-  .default({})
-
-// ---------------------------------------------------------------------------
-// Seed - empty by default; adapters populate with real role definitions.
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_ORGANIZATION_MODEL_ROLES: z.infer<typeof RolesDomainSchema> = {}
-
-export type RoleId = z.infer<typeof RoleIdSchema>
-export type HumanRoleHolder = z.infer<typeof HumanRoleHolderSchema>
-export type AgentRoleHolder = z.infer<typeof AgentRoleHolderSchema>
-export type TeamRoleHolder = z.infer<typeof TeamRoleHolderSchema>
-export type RoleHolder = z.infer<typeof RoleHolderSchema>
-export type Role = z.infer<typeof RoleSchema>
-export type RolesDomain = z.infer<typeof RolesDomainSchema>
+import { z } from 'zod'
+import { ResourceIdSchema } from './resources'
+import { ModelIdSchema } from './shared'
+import { SystemIdSchema } from './systems'
+import { defineDomainRecord } from '../helpers'
+
+// ---------------------------------------------------------------------------
+// Role schema - one entry per distinct role in the organization's chart.
+// Inspired by the EOS Accountability Chart but uses plain-language field names
+// throughout. No EOS jargon: "title" (not seatTitle), "responsibilities"
+// (not accountabilities), "reportsToId", "heldBy".
+//
+// Cross-reference enforcement lives in `OrganizationModelSchema.superRefine()`:
+// `reportsToId` must resolve to another Role, `responsibleFor` entries must
+// resolve to Systems, and agent holders must resolve to Agent Resources.
+// Role hierarchy cycle detection is also enforced at the model level.
+// ---------------------------------------------------------------------------
+
+export const RoleIdSchema = ModelIdSchema
+
+export const HumanRoleHolderSchema = z.object({
+  kind: z.literal('human'),
+  userId: z.string().trim().min(1).max(200)
+})
+
+export const AgentRoleHolderSchema = z.object({
+  kind: z.literal('agent'),
+  agentId: ResourceIdSchema.meta({ ref: 'resource' })
+})
+
+export const TeamRoleHolderSchema = z.object({
+  kind: z.literal('team'),
+  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
+})
+
+export const RoleHolderSchema = z.discriminatedUnion('kind', [
+  HumanRoleHolderSchema,
+  AgentRoleHolderSchema,
+  TeamRoleHolderSchema
+])
+
+export const RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)])
+
+export const RoleSchema = z.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: RoleIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
+  title: z.string().trim().min(1).max(200),
+  /**
+   * List of responsibilities this role owns - plain-language descriptions of
+   * what the person in this role is accountable for delivering.
+   * Defaults to empty array so minimal role definitions stay concise.
+   */
+  responsibilities: z.array(z.string().trim().max(500)).default([]),
+  /**
+   * Optional: ID of another role this role reports to.
+   * When present, must reference another `roles[].id` in the same organization.
+   */
+  reportsToId: RoleIdSchema.meta({ ref: 'role' }).optional(),
+  /**
+   * Optional: human, agent, or team holder currently filling this role.
+   * Agent holders reference OM Resource IDs and are validated at the model level.
+   */
+  heldBy: RoleHoldersSchema.optional(),
+  /**
+   * Optional Systems this role is accountable for.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  responsibleFor: z.array(SystemIdSchema.meta({ ref: 'system' })).optional()
+})
+
+// ---------------------------------------------------------------------------
+// Roles domain schema - a collection of roles.
+// ---------------------------------------------------------------------------
+
+export const RolesDomainSchema = z
+  .record(z.string(), RoleSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each role entry id must match its map key'
+  })
+  .default({})
+
+// ---------------------------------------------------------------------------
+// Seed - empty by default; adapters populate with real role definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_ROLES: z.infer<typeof RolesDomainSchema> = {}
+
+/** Validate and return a single role entry. */
+export function defineRole(entry: z.input<typeof RoleSchema>): z.infer<typeof RoleSchema> {
+  return RoleSchema.parse(entry)
+}
+
+/** Validate and return an id-keyed map of role entries. */
+export function defineRoles(
+  entries: readonly z.input<typeof RoleSchema>[]
+): Record<string, z.infer<typeof RoleSchema>> {
+  return defineDomainRecord(RoleSchema, entries)
+}
+
+export type RoleId = z.infer<typeof RoleIdSchema>
+export type HumanRoleHolder = z.infer<typeof HumanRoleHolderSchema>
+export type AgentRoleHolder = z.infer<typeof AgentRoleHolderSchema>
+export type TeamRoleHolder = z.infer<typeof TeamRoleHolderSchema>
+export type RoleHolder = z.infer<typeof RoleHolderSchema>
+export type Role = z.infer<typeof RoleSchema>
+export type RolesDomain = z.infer<typeof RolesDomainSchema>

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

@@ -1,218 +1,104 @@
-import { describe, it, expect } from 'vitest'
-import {
-  CRM_PIPELINE_DEFINITION,
-  CRM_DISCOVERY_REPLIED_STATE,
-  CRM_DISCOVERY_LINK_SENT_STATE,
-  CRM_DISCOVERY_NUDGING_STATE,
-  CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
-  CRM_REPLY_SENT_STATE,
-  CRM_FOLLOWUP_1_SENT_STATE,
-  CRM_FOLLOWUP_2_SENT_STATE,
-  CRM_FOLLOWUP_3_SENT_STATE,
-  CRM_PRIORITY_BUCKETS,
-  DEFAULT_CRM_PRIORITY_RULE_CONFIG,
-  getValidStatesForStage,
-  findPipeline,
-  ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE,
-  ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE,
-  LEAD_GEN_PIPELINE_DEFINITIONS
-} from './sales'
-
-describe('CRM_PIPELINE_DEFINITION', () => {
-  it('has pipelineKey "crm"', () => {
-    expect(CRM_PIPELINE_DEFINITION.pipelineKey).toBe('crm')
-  })
-
-  it('has entityKey "crm.deal"', () => {
-    expect(CRM_PIPELINE_DEFINITION.entityKey).toBe('crm.deal')
-  })
-
-  it('has exactly 6 stages', () => {
-    expect(CRM_PIPELINE_DEFINITION.stages).toHaveLength(6)
-  })
-
-  it('stage keys are interested, proposal, closing, closed_won, closed_lost, nurturing in order', () => {
-    const keys = CRM_PIPELINE_DEFINITION.stages.map((s) => s.stageKey)
-    expect(keys).toEqual(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])
-  })
-
-  it('interested stage has exactly 8 states', () => {
-    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')
-    expect(interested?.states).toHaveLength(8)
-  })
-
-  it('interested stage contains all 8 expected state constants', () => {
-    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')!
-    const stateKeys = interested.states.map((s) => s.stateKey)
-    expect(stateKeys).toContain(CRM_DISCOVERY_REPLIED_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_DISCOVERY_LINK_SENT_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_DISCOVERY_NUDGING_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_DISCOVERY_BOOKING_CANCELLED_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_REPLY_SENT_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_FOLLOWUP_1_SENT_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_FOLLOWUP_2_SENT_STATE.stateKey)
-    expect(stateKeys).toContain(CRM_FOLLOWUP_3_SENT_STATE.stateKey)
-  })
-
-  it('interested stage states reference the exported constants by identity', () => {
-    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')!
-    expect(interested.states).toContain(CRM_DISCOVERY_REPLIED_STATE)
-    expect(interested.states).toContain(CRM_FOLLOWUP_3_SENT_STATE)
-  })
-
-  it.each(['proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])(
-    '%s stage has an empty states array',
-    (stageKey) => {
-      const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === stageKey)
-      expect(stage).toBeDefined()
-      expect(stage?.states).toHaveLength(0)
-    }
-  )
-
-  it('closed_won stage has empty states array', () => {
-    const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'closed_won')
-    expect(stage?.states).toEqual([])
-  })
-
-  it('closed_lost stage has empty states array', () => {
-    const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'closed_lost')
-    expect(stage?.states).toEqual([])
-  })
-})
-
-describe('CRM state constant shapes', () => {
-  it('CRM_DISCOVERY_REPLIED_STATE has correct stateKey and label', () => {
-    expect(CRM_DISCOVERY_REPLIED_STATE).toEqual({ stateKey: 'discovery_replied', label: 'Discovery Replied' })
-  })
-
-  it('CRM_FOLLOWUP_1_SENT_STATE has correct stateKey and label', () => {
-    expect(CRM_FOLLOWUP_1_SENT_STATE).toEqual({ stateKey: 'followup_1_sent', label: 'Follow-up 1 Sent' })
-  })
-
-  it('CRM_FOLLOWUP_2_SENT_STATE has correct stateKey and label', () => {
-    expect(CRM_FOLLOWUP_2_SENT_STATE).toEqual({ stateKey: 'followup_2_sent', label: 'Follow-up 2 Sent' })
-  })
-
-  it('CRM_FOLLOWUP_3_SENT_STATE has correct stateKey and label', () => {
-    expect(CRM_FOLLOWUP_3_SENT_STATE).toEqual({ stateKey: 'followup_3_sent', label: 'Follow-up 3 Sent' })
-  })
-})
-
-describe('DEFAULT_CRM_PRIORITY_RULE_CONFIG', () => {
-  it('defines the canonical CRM priority buckets in sort order', () => {
-    expect(CRM_PRIORITY_BUCKETS.map((bucket) => bucket.bucketKey)).toEqual([
-      'needs_response',
-      'follow_up_due',
-      'waiting',
-      'stale',
-      'closed_low'
-    ])
-    expect(CRM_PRIORITY_BUCKETS.map((bucket) => bucket.rank)).toEqual([10, 20, 30, 40, 50])
-  })
-
-  it('includes display metadata for each bucket', () => {
-    for (const bucket of CRM_PRIORITY_BUCKETS) {
-      expect(bucket.label).toEqual(expect.any(String))
-      expect(bucket.rank).toEqual(expect.any(Number))
-      expect(bucket.color).toEqual(expect.any(String))
-    }
-  })
-
-  it('maps CRM states and closed stages into priority rules', () => {
-    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys).toEqual(['closed_won', 'closed_lost'])
-    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.followUpAfterDaysByStateKey.discovery_link_sent).toBe(3)
-    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays).toBeGreaterThan(0)
-  })
-})
-
-describe('getValidStatesForStage', () => {
-  it('returns all 8 states for the interested stage', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'interested')
-    expect(states).toHaveLength(8)
-    expect(states.map((s) => s.stateKey)).toContain('discovery_replied')
-    expect(states.map((s) => s.stateKey)).toContain('followup_3_sent')
-  })
-
-  it('returns empty array for the proposal stage (no states defined)', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'proposal')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for the closing stage (no states defined)', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closing')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for closed_won stage', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closed_won')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for closed_lost stage', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closed_lost')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for nurturing stage (no states defined)', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'nurturing')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for an unknown stage key', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'unknown_stage')
-    expect(states).toEqual([])
-  })
-
-  it('returns empty array for an empty string stage key', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, '')
-    expect(states).toEqual([])
-  })
-
-  it('is case-sensitive — "Interested" does not match "interested"', () => {
-    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'Interested')
-    expect(states).toEqual([])
-  })
-
-  it('works with the lead-gen member pipeline for known stage', () => {
-    const states = getValidStatesForStage(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE, 'outreach')
-    expect(states.length).toBeGreaterThan(0)
-    expect(states.map((s) => s.stateKey)).toContain('personalized')
-  })
-
-  it('works with the lead-gen member pipeline for unknown stage', () => {
-    const states = getValidStatesForStage(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE, 'nonexistent')
-    expect(states).toEqual([])
-  })
-})
-
-describe('findPipeline', () => {
-  it('finds a pipeline by pipelineKey when present', () => {
-    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'lead-gen')
-    expect(found).toBe(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
-  })
-
-  it('returns undefined for an unknown pipelineKey', () => {
-    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'crm')
-    expect(found).toBeUndefined()
-  })
-
-  it('returns undefined for an empty array', () => {
-    const found = findPipeline([], 'lead-gen')
-    expect(found).toBeUndefined()
-  })
-})
-
-describe('LEAD_GEN_PIPELINE_DEFINITIONS', () => {
-  it('has entries for acq.list-member and acq.list-company', () => {
-    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-member')
-    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-company')
-  })
-
-  it('acq.list-member entry contains the ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE', () => {
-    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member']).toContain(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
-  })
-
-  it('acq.list-company entry contains the ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE', () => {
-    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-company']).toContain(ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE)
-  })
-})
+import { describe, expect, it } from 'vitest'
+import {
+  ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE,
+  ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE,
+  LEAD_GEN_PIPELINE_DEFINITIONS,
+  findPipeline,
+  getValidStatesForStage,
+  type StatefulPipelineDefinition
+} from './sales'
+
+const TEST_CRM_PIPELINE: StatefulPipelineDefinition = {
+  pipelineKey: 'crm',
+  label: 'CRM',
+  entityKey: 'crm.deal',
+  stages: [
+    {
+      stageKey: 'interested',
+      label: 'Interested',
+      color: 'blue',
+      states: [
+        { stateKey: 'discovery_replied', label: 'Discovery Replied' },
+        { stateKey: 'discovery_link_sent', label: 'Discovery Link Sent' }
+      ]
+    },
+    { stageKey: 'proposal', label: 'Proposal', color: 'yellow', states: [] }
+  ]
+}
+
+describe('sales domain published surface', () => {
+  it('does not export Elevasis CRM runtime constants from the generic core sales domain', async () => {
+    const sales = await import('./sales')
+
+    expect(Object.keys(sales)).not.toEqual(
+      expect.arrayContaining([
+        'CRM_PIPELINE_DEFINITION',
+        'CRM_DISCOVERY_REPLIED_STATE',
+        'CRM_PRIORITY_BUCKETS',
+        'DEFAULT_CRM_PRIORITY_RULE_CONFIG',
+        'DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG'
+      ])
+    )
+  })
+})
+
+describe('getValidStatesForStage', () => {
+  it('returns states for a known stage from a caller-supplied pipeline definition', () => {
+    const states = getValidStatesForStage(TEST_CRM_PIPELINE, 'interested')
+
+    expect(states).toEqual([
+      { stateKey: 'discovery_replied', label: 'Discovery Replied' },
+      { stateKey: 'discovery_link_sent', label: 'Discovery Link Sent' }
+    ])
+  })
+
+  it('returns empty array for a stage with no states', () => {
+    expect(getValidStatesForStage(TEST_CRM_PIPELINE, 'proposal')).toEqual([])
+  })
+
+  it('returns empty array for an unknown stage key', () => {
+    expect(getValidStatesForStage(TEST_CRM_PIPELINE, 'unknown_stage')).toEqual([])
+  })
+
+  it('is case-sensitive', () => {
+    expect(getValidStatesForStage(TEST_CRM_PIPELINE, 'Interested')).toEqual([])
+  })
+
+  it('works with the lead-gen member pipeline for known stage', () => {
+    const states = getValidStatesForStage(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE, 'outreach')
+    expect(states.length).toBeGreaterThan(0)
+    expect(states.map((s) => s.stateKey)).toContain('personalized')
+  })
+})
+
+describe('findPipeline', () => {
+  it('finds a pipeline by pipelineKey when present', () => {
+    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'lead-gen')
+    expect(found).toBe(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
+  })
+
+  it('returns undefined for an unknown pipelineKey', () => {
+    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'crm')
+    expect(found).toBeUndefined()
+  })
+
+  it('returns undefined for an empty array', () => {
+    const found = findPipeline([], 'lead-gen')
+    expect(found).toBeUndefined()
+  })
+})
+
+describe('LEAD_GEN_PIPELINE_DEFINITIONS', () => {
+  it('has entries for acq.list-member and acq.list-company', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-member')
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-company')
+  })
+
+  it('acq.list-member entry contains the ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member']).toContain(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
+  })
+
+  it('acq.list-company entry contains the ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-company']).toContain(ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE)
+  })
+})