@elevasis/core 0.19.0 → 0.21.0

package/src/business/acquisition/api-schemas.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import {
+  CRM_PIPELINE_DEFINITION,
   DEFAULT_CRM_PRIORITY_RULE_CONFIG,
   LEAD_GEN_PIPELINE_DEFINITIONS,
   LEAD_GEN_STAGE_CATALOG
@@ -19,6 +20,9 @@ import {
   CreateContactRequestSchema,
   CreateDealNoteRequestSchema,
   CreateDealTaskRequestSchema,
+  CrmStageKeySchema,
+  CrmStateKeySchema,
+  CrmTransitionItemRequestSchema,
   CreateListRequestSchema,
   DealDetailResponseSchema,
   DealListItemSchema,
@@ -34,9 +38,11 @@ import {
   ListDealsQuerySchema,
   ListDealTasksDueQuerySchema,
   ListMembersQuerySchema,
+  ListRecordsQuerySchema,
   ListStatusSchema,
   PipelineStageSchema,
   ScrapingConfigSchema,
+  TransitionDealStateRequestSchema,
   TransitionItemRequestSchema,
   UpdateCompanyRequestSchema,
   UpdateContactRequestSchema,
@@ -67,17 +73,31 @@ const PRIORITY = {
 // ---------------------------------------------------------------------------
 
 describe('DealStageSchema', () => {
-  it.each(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])(
-    'accepts canonical stage "%s"',
-    (stage) => {
-      expect(DealStageSchema.safeParse(stage).success).toBe(true)
-    }
-  )
+  const crmStageKeys = CRM_PIPELINE_DEFINITION.stages.map((stage) => stage.stageKey)
+  const crmStateKeys = CRM_PIPELINE_DEFINITION.stages.flatMap((stage) => stage.states.map((state) => state.stateKey))
+
+  it('derives CRM stage keys from CRM_PIPELINE_DEFINITION', () => {
+    expect(CrmStageKeySchema.options).toEqual(crmStageKeys)
+    expect(DealStageSchema.options).toEqual(crmStageKeys)
+  })
+
+  it('derives CRM state keys from CRM_PIPELINE_DEFINITION', () => {
+    expect(CrmStateKeySchema.options).toEqual(crmStateKeys)
+  })
+
+  it.each(crmStageKeys)('accepts canonical stage "%s"', (stage) => {
+    expect(DealStageSchema.safeParse(stage).success).toBe(true)
+  })
 
   it('rejects an unknown stage value', () => {
     expect(DealStageSchema.safeParse('open').success).toBe(false)
     expect(DealStageSchema.safeParse('').success).toBe(false)
   })
+
+  it('rejects unknown CRM state values', () => {
+    expect(CrmStateKeySchema.safeParse('custom_state').success).toBe(false)
+    expect(CrmStateKeySchema.safeParse('').success).toBe(false)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -86,7 +106,7 @@ describe('DealStageSchema', () => {
 
 describe('TransitionItemRequestSchema', () => {
   const valid = {
-    pipelineKey: 'default',
+    pipelineKey: 'lead-gen',
     stageKey: 'interested',
     stateKey: null
   }
@@ -122,11 +142,16 @@ describe('TransitionItemRequestSchema', () => {
   })
 
   it('accepts all canonical CRM deal stages', () => {
-    const stages = ['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing']
-    for (const stageKey of stages) {
-      expect(TransitionItemRequestSchema.safeParse({ pipelineKey: 'default', stageKey, stateKey: null }).success).toBe(
-        true
-      )
+    for (const stageKey of CRM_PIPELINE_DEFINITION.stages.map((stage) => stage.stageKey)) {
+      expect(TransitionItemRequestSchema.safeParse({ pipelineKey: 'crm', stageKey, stateKey: null }).success).toBe(true)
+    }
+  })
+
+  it('accepts catalog-derived CRM state keys', () => {
+    for (const stateKey of CRM_PIPELINE_DEFINITION.stages.flatMap((stage) =>
+      stage.states.map((state) => state.stateKey)
+    )) {
+      expect(TransitionItemRequestSchema.safeParse({ ...valid, stateKey }).success).toBe(true)
     }
   })
 
@@ -158,6 +183,11 @@ describe('TransitionItemRequestSchema', () => {
     expect(result.success).toBe(false)
   })
 
+  it('accepts unknown non-empty stage and state keys for generic substrate transitions', () => {
+    expect(TransitionItemRequestSchema.safeParse({ ...valid, stageKey: 'custom_stage' }).success).toBe(true)
+    expect(TransitionItemRequestSchema.safeParse({ ...valid, stateKey: 'custom_state' }).success).toBe(true)
+  })
+
   it('rejects unknown top-level fields (strict mode)', () => {
     const result = TransitionItemRequestSchema.safeParse({ ...valid, unknownField: 'x' })
     expect(result.success).toBe(false)
@@ -176,6 +206,64 @@ describe('TransitionItemRequestSchema', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// CrmTransitionItemRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CrmTransitionItemRequestSchema', () => {
+  const valid = {
+    pipelineKey: 'crm',
+    stageKey: 'interested',
+    stateKey: null
+  }
+
+  it('accepts catalog-derived CRM stage and state keys', () => {
+    for (const stageKey of CRM_PIPELINE_DEFINITION.stages.map((stage) => stage.stageKey)) {
+      expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stageKey }).success).toBe(true)
+    }
+
+    for (const stateKey of CRM_PIPELINE_DEFINITION.stages.flatMap((stage) =>
+      stage.states.map((state) => state.stateKey)
+    )) {
+      expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stateKey }).success).toBe(true)
+    }
+  })
+
+  it('rejects non-CRM pipeline keys and unknown CRM keys', () => {
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, pipelineKey: 'lead-gen' }).success).toBe(false)
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stageKey: 'unknown_stage' }).success).toBe(false)
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stateKey: 'unknown_state' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// TransitionDealStateRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('TransitionDealStateRequestSchema', () => {
+  it('accepts catalog-derived CRM state keys', () => {
+    for (const stateKey of CRM_PIPELINE_DEFINITION.stages.flatMap((stage) =>
+      stage.states.map((state) => state.stateKey)
+    )) {
+      expect(TransitionDealStateRequestSchema.safeParse({ stateKey }).success).toBe(true)
+    }
+  })
+
+  it('rejects unknown state values', () => {
+    expect(TransitionDealStateRequestSchema.safeParse({ stateKey: 'unknown_state' }).success).toBe(false)
+    expect(TransitionDealStateRequestSchema.safeParse({ stateKey: '' }).success).toBe(false)
+  })
+
+  it('preserves strict request schema behavior', () => {
+    expect(
+      TransitionDealStateRequestSchema.safeParse({
+        stateKey: CRM_PIPELINE_DEFINITION.stages[0]?.states[0]?.stateKey,
+        extra: 'x'
+      }).success
+    ).toBe(false)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // ExecuteActionRequestSchema
 // ---------------------------------------------------------------------------
@@ -698,7 +786,7 @@ describe('DealDetailResponseSchema (forward-compat)', () => {
     organization_id: VALID_UUID,
     contact_id: null,
     contact_email: 'test@example.com',
-    pipeline_key: 'default',
+    pipeline_key: 'crm',
     stage_key: null,
     state_key: null,
     activity_log: [],
@@ -1514,6 +1602,30 @@ describe('ListMembersQuerySchema', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// ListRecordsQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListRecordsQuerySchema', () => {
+  it('accepts contact records for DTC decision-maker enrichment', () => {
+    const result = ListRecordsQuerySchema.safeParse({
+      entity: 'contact',
+      stage: 'decision-makers-enriched'
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('keeps company records valid for qualified and uploaded stages', () => {
+    expect(ListRecordsQuerySchema.safeParse({ entity: 'company', stage: 'qualified' }).success).toBe(true)
+    expect(ListRecordsQuerySchema.safeParse({ entity: 'company', stage: 'uploaded' }).success).toBe(true)
+  })
+
+  it('still rejects unrelated stage/entity combinations', () => {
+    expect(ListRecordsQuerySchema.safeParse({ entity: 'contact', stage: 'qualified' }).success).toBe(false)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // AcqListResponseSchema (forward-compat)
 // ---------------------------------------------------------------------------
@@ -1585,5 +1697,4 @@ describe('AcqContactResponseSchema (forward-compat)', () => {
   it('rejects an invalid emailValid value', () => {
     expect(AcqContactResponseSchema.safeParse({ ...baseContact, emailValid: 'BAD' }).success).toBe(false)
   })
-
 })

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

@@ -1,7 +1,11 @@
 import { z } from 'zod'
 import { UuidSchema, NonEmptyStringSchema } from '../../platform/utils/validation'
-import { LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
-import { CAPABILITY_REGISTRY } from '../../organization-model/domains/prospecting'
+import { CRM_PIPELINE_DEFINITION, LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
+import {
+  CAPABILITY_REGISTRY,
+  CredentialRequirementSchema,
+  RecordColumnConfigSchema
+} from '../../organization-model/domains/prospecting'
 import { isProspectingBuildTemplateId } from './build-templates'
 export { CrmPriorityBucketKeySchema, CrmPriorityBucketOverrideSchema, CrmPriorityOverrideSchema } from './crm-priority'
 export type { CrmPriorityBucketOverride, CrmPriorityOverride, ResolvedCrmPriorityRuleConfig } from './crm-priority'
@@ -16,10 +20,19 @@ export const LeadGenStageKeySchema = z
 
 export const LeadGenCapabilityKeySchema = z
   .string()
-  .refine((value) => Object.prototype.hasOwnProperty.call(CAPABILITY_REGISTRY, value), {
+  .refine((value) => CAPABILITY_REGISTRY.some((c) => c.id === value), {
     message: 'capabilityKey must match CAPABILITY_REGISTRY'
   })
 
+const crmStageKeys = CRM_PIPELINE_DEFINITION.stages.map((stage) => stage.stageKey) as [string, ...string[]]
+const crmStateKeys = CRM_PIPELINE_DEFINITION.stages.flatMap((stage) => stage.states.map((state) => state.stateKey)) as [
+  string,
+  ...string[]
+]
+
+export const CrmStageKeySchema = z.enum(crmStageKeys)
+export const CrmStateKeySchema = z.enum(crmStateKeys)
+
 export const ProcessingStateEntrySchema = z
   .object({
     status: ProcessingStageStatusSchema,
@@ -47,7 +60,7 @@ export const ContactProcessingStateSchema = ProcessingStateSchema
 // Enum literals (must match DB CHECK constraints exactly)
 // ---------------------------------------------------------------------------
 
-export const DealStageSchema = z.enum(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])
+export const DealStageSchema = CrmStageKeySchema
 
 export const AcqDealTaskKindSchema = z.enum(['call', 'email', 'meeting', 'other'])
 
@@ -115,7 +128,17 @@ export const TransitionItemRequestSchema = z
   .object({
     pipelineKey: z.string().min(1),
     stageKey: z.string().min(1),
-    stateKey: z.string().nullable().optional(),
+    stateKey: z.string().min(1).nullable().optional(),
+    reason: z.string().optional(),
+    expectedUpdatedAt: z.string().datetime().optional()
+  })
+  .strict()
+
+export const CrmTransitionItemRequestSchema = z
+  .object({
+    pipelineKey: z.literal(CRM_PIPELINE_DEFINITION.pipelineKey),
+    stageKey: CrmStageKeySchema,
+    stateKey: CrmStateKeySchema.nullable().optional(),
     reason: z.string().optional(),
     expectedUpdatedAt: z.string().datetime().optional()
   })
@@ -123,7 +146,7 @@ export const TransitionItemRequestSchema = z
 
 export const TransitionDealStateRequestSchema = z
   .object({
-    stateKey: z.string().min(1),
+    stateKey: CrmStateKeySchema,
     reason: z.string().optional(),
     expectedUpdatedAt: z.string().datetime().optional()
   })
@@ -331,6 +354,11 @@ export const DealTaskListResponseSchema = z.array(DealTaskResponseSchema)
 // ---------------------------------------------------------------------------
 
 export const DealSchemas = {
+  // Primitives
+  CrmStageKey: CrmStageKeySchema,
+  CrmStateKey: CrmStateKeySchema,
+  DealStage: DealStageSchema,
+
   // Params
   DealIdParams: DealIdParamsSchema,
   DealTaskIdParams: DealTaskIdParamsSchema,
@@ -343,7 +371,7 @@ export const DealSchemas = {
   // Request bodies
   CreateDealNoteRequest: CreateDealNoteRequestSchema,
   CreateDealTaskRequest: CreateDealTaskRequestSchema,
-  TransitionItemRequest: TransitionItemRequestSchema,
+  TransitionItemRequest: CrmTransitionItemRequestSchema,
   TransitionDealStateRequest: TransitionDealStateRequestSchema,
   ExecuteActionParams: ExecuteActionParamsSchema,
   ExecuteActionRequest: ExecuteActionRequestSchema,
@@ -366,6 +394,8 @@ export const DealSchemas = {
 // ---------------------------------------------------------------------------
 
 export type DealStage = z.infer<typeof DealStageSchema>
+export type CrmStageKey = z.infer<typeof CrmStageKeySchema>
+export type CrmStateKey = z.infer<typeof CrmStateKeySchema>
 export type AcqDealTaskKind = z.infer<typeof AcqDealTaskKindSchema>
 export type DealIdParams = z.infer<typeof DealIdParamsSchema>
 export type DealTaskIdParams = z.infer<typeof DealTaskIdParamsSchema>
@@ -375,6 +405,7 @@ export type ListDealTasksDueQuery = z.infer<typeof ListDealTasksDueQuerySchema>
 export type CreateDealNoteRequest = z.infer<typeof CreateDealNoteRequestSchema>
 export type CreateDealTaskRequest = z.infer<typeof CreateDealTaskRequestSchema>
 export type TransitionItemRequest = z.infer<typeof TransitionItemRequestSchema>
+export type CrmTransitionItemRequest = z.infer<typeof CrmTransitionItemRequestSchema>
 export type TransitionDealStateRequest = z.infer<typeof TransitionDealStateRequestSchema>
 export type ExecuteActionParams = z.infer<typeof ExecuteActionParamsSchema>
 export type ExecuteActionRequest = z.infer<typeof ExecuteActionRequestSchema>
@@ -469,11 +500,21 @@ export const BuildPlanSnapshotStepSchema = z
     primaryEntity: z.enum(['company', 'contact']),
     outputs: z.array(z.enum(['company', 'contact', 'export'])).min(1),
     stageKey: LeadGenStageKeySchema,
+    recordEntity: z.enum(['company', 'contact']).optional(),
+    recordsStageKey: LeadGenStageKeySchema.optional(),
+    recordSourceStageKey: LeadGenStageKeySchema.optional(),
     dependsOn: z.array(z.string().trim().min(1).max(100)).optional(),
     dependencyMode: z.literal('per-record-eligibility'),
     capabilityKey: LeadGenCapabilityKeySchema,
     defaultBatchSize: z.number().int().positive(),
-    maxBatchSize: z.number().int().positive()
+    maxBatchSize: z.number().int().positive(),
+    recordColumns: z
+      .object({
+        company: z.array(RecordColumnConfigSchema).optional(),
+        contact: z.array(RecordColumnConfigSchema).optional()
+      })
+      .optional(),
+    credentialRequirements: z.array(CredentialRequirementSchema).optional()
   })
   .refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
     message: 'defaultBatchSize must be less than or equal to maxBatchSize',
@@ -1036,6 +1077,33 @@ export const ListMembersQuerySchema = z
   })
   .strict()
 
+export const ListRecordEntitySchema = z.enum(['company', 'contact'])
+
+export const ListRecordsQuerySchema = z
+  .object({
+    entity: ListRecordEntitySchema,
+    stage: LeadGenStageKeySchema.optional(),
+    limit: z.coerce.number().int().min(1).max(500).default(50),
+    offset: z.coerce.number().int().min(0).default(0)
+  })
+  .strict()
+  .superRefine((query, ctx) => {
+    if (!query.stage) return
+
+    const stage = LEAD_GEN_STAGE_CATALOG[query.stage]
+    const validEntity =
+      stage?.entity === query.entity ||
+      stage?.additionalEntities?.includes(query.entity) ||
+      stage?.recordEntity === query.entity
+    if (!validEntity) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `stage "${query.stage}" is not valid for ${query.entity} records`,
+        path: ['stage']
+      })
+    }
+  })
+
 export const MemberIdParamsSchema = z.object({
   memberId: UuidSchema
 })
@@ -1068,6 +1136,77 @@ export const AcqListMembersResponseSchema = z.object({
   members: z.array(AcqListMemberResponseSchema)
 })
 
+export const AcqListRecordCompanySummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  domain: z.string().nullable(),
+  website: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  numEmployees: z.number().nullable(),
+  foundedYear: z.number().nullable(),
+  locationCity: z.string().nullable(),
+  locationState: z.string().nullable(),
+  category: z.string().nullable(),
+  segment: z.string().nullable(),
+  status: AcqCompanyStatusSchema,
+  qualificationScore: z.number().nullable(),
+  qualificationSignals: z.record(z.string(), z.unknown()).nullable(),
+  qualificationRubricKey: z.string().nullable()
+})
+
+export const AcqListRecordContactSummarySchema = z.object({
+  id: z.string(),
+  email: z.string(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  title: z.string().nullable(),
+  headline: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  companyId: z.string().nullable(),
+  status: AcqContactStatusSchema,
+  qualificationScore: z.number().nullable(),
+  qualificationSignals: z.record(z.string(), z.unknown()).nullable(),
+  qualificationRubricKey: z.string().nullable()
+})
+
+const ListRecordBaseSchema = z.object({
+  id: z.string(),
+  listId: z.string(),
+  pipelineKey: z.string(),
+  stageKey: z.string(),
+  stateKey: z.string(),
+  activityLog: z.unknown(),
+  addedAt: z.string(),
+  addedBy: z.string().nullable(),
+  sourceExecutionId: z.string().nullable(),
+  processingState: z.record(z.string(), z.unknown()).nullable(),
+  enrichmentData: z.record(z.string(), z.unknown()).nullable()
+})
+
+export const AcqListCompanyRecordRowSchema = ListRecordBaseSchema.extend({
+  entity: z.literal('company'),
+  companyId: z.string(),
+  company: AcqListRecordCompanySummarySchema.nullable()
+})
+
+export const AcqListContactRecordRowSchema = ListRecordBaseSchema.extend({
+  entity: z.literal('contact'),
+  contactId: z.string(),
+  contact: AcqListRecordContactSummarySchema.nullable()
+})
+
+export const ListRecordRowSchema = z.discriminatedUnion('entity', [
+  AcqListCompanyRecordRowSchema,
+  AcqListContactRecordRowSchema
+])
+
+export const ListRecordsResponseSchema = z.object({
+  data: z.array(ListRecordRowSchema),
+  total: z.number().int().min(0),
+  limit: z.number().int().min(1),
+  offset: z.number().int().min(0)
+})
+
 // ---------------------------------------------------------------------------
 // Track B: List Companies API Schemas
 // ---------------------------------------------------------------------------
@@ -1090,8 +1229,8 @@ export const AcqListCompanyResponseSchema = z.object({
 })
 
 // ---------------------------------------------------------------------------
-// Track B: Transition Request (shared by list, list-member, list-company)
-// TransitionItemRequestSchema already exists above (for deals) — reuse it.
+// Track B: Transition request for list, list-member, and list-company substrate routes.
+// CRM deals use DealSchemas.TransitionItemRequest, which is catalog-backed.
 // ---------------------------------------------------------------------------
 
 export const AcqCompanySchemas = {
@@ -1189,15 +1328,20 @@ export const AcqSubstrateSchemas = {
 
   // List members
   ListMembersQuery: ListMembersQuerySchema,
+  ListRecordsQuery: ListRecordsQuerySchema,
   MemberIdParams: MemberIdParamsSchema,
   AcqListMemberResponse: AcqListMemberResponseSchema,
   AcqListMembersResponse: AcqListMembersResponseSchema,
+  AcqListCompanyRecordRow: AcqListCompanyRecordRowSchema,
+  AcqListContactRecordRow: AcqListContactRecordRowSchema,
+  ListRecordRow: ListRecordRowSchema,
+  ListRecordsResponse: ListRecordsResponseSchema,
 
   // List companies
   ListCompanyIdParams: ListCompanyIdParamsSchema,
   AcqListCompanyResponse: AcqListCompanyResponseSchema,
 
-  // Transition (shared with deals — TransitionItemRequestSchema)
+  // Transition (generic stateful substrate)
   TransitionItemRequest: TransitionItemRequestSchema
 }
 
@@ -1215,10 +1359,16 @@ export type CreateArtifactRequest = z.infer<typeof CreateArtifactRequestSchema>
 export type AcqArtifactResponse = z.infer<typeof AcqArtifactResponseSchema>
 export type AcqArtifactListResponse = z.infer<typeof AcqArtifactListResponseSchema>
 export type ListMembersQuery = z.infer<typeof ListMembersQuerySchema>
+export type ListRecordEntity = z.infer<typeof ListRecordEntitySchema>
+export type ListRecordsQuery = z.infer<typeof ListRecordsQuerySchema>
 export type MemberIdParams = z.infer<typeof MemberIdParamsSchema>
 export type AcqListMemberContactSummary = z.infer<typeof AcqListMemberContactSummarySchema>
 export type AcqListMemberResponse = z.infer<typeof AcqListMemberResponseSchema>
 export type AcqListMembersResponse = z.infer<typeof AcqListMembersResponseSchema>
+export type AcqListCompanyRecordRow = z.infer<typeof AcqListCompanyRecordRowSchema>
+export type AcqListContactRecordRow = z.infer<typeof AcqListContactRecordRowSchema>
+export type ListRecordRow = z.infer<typeof ListRecordRowSchema>
+export type ListRecordsResponse = z.infer<typeof ListRecordsResponseSchema>
 export type ListCompanyIdParams = z.infer<typeof ListCompanyIdParamsSchema>
 export type AcqListCompanyResponse = z.infer<typeof AcqListCompanyResponseSchema>
 

package/src/business/acquisition/build-templates.test.ts

@@ -180,12 +180,40 @@ describe('createBuildPlanSnapshotFromTemplateId — "dtc-subscription-apollo-cli
     expect(first?.outputs).toContain('contact')
   })
 
+  it('preserves Apollo credential requirements for source import and decision-maker enrichment', () => {
+    const importApolloSearch = snapshot?.steps.find((step) => step.id === 'import-apollo-search')
+    const enrichDecisionMakers = snapshot?.steps.find((step) => step.id === 'enrich-decision-makers')
+
+    const expectedRequirement = {
+      key: 'apollo',
+      provider: 'apollo',
+      credentialType: 'api-key-secret',
+      label: 'Apollo API key',
+      required: true,
+      selectionMode: 'single',
+      inputPath: 'credential'
+    }
+
+    expect(importApolloSearch?.credentialRequirements).toEqual([expectedRequirement])
+    expect(enrichDecisionMakers?.credentialRequirements).toEqual([expectedRequirement])
+  })
+
   it('the final step (review-and-export) outputs export', () => {
     const last = snapshot?.steps[snapshot.steps.length - 1]
     expect(last?.id).toBe('review-and-export')
     expect(last?.outputs).toContain('export')
   })
 
+  it('preserves contact records metadata for the company-owned decision-maker step', () => {
+    const decisionMakers = snapshot?.steps.find((step) => step.id === 'enrich-decision-makers')
+    expect(decisionMakers).toMatchObject({
+      primaryEntity: 'company',
+      recordEntity: 'contact',
+      stageKey: 'decision-makers-enriched'
+    })
+    expect(decisionMakers?.recordColumns?.contact?.length).toBeGreaterThan(0)
+  })
+
   it('steps with descriptions in the catalog include description in the snapshot', () => {
     const withDesc = snapshot?.steps.filter((step) => step.description !== undefined) ?? []
     expect(withDesc.length).toBeGreaterThan(0)

package/src/business/acquisition/build-templates.ts

@@ -29,16 +29,28 @@ export function createBuildPlanSnapshotFromTemplateId(templateId: string): Build
         primaryEntity: step.primaryEntity,
         outputs: [...step.outputs],
         stageKey: step.stageKey,
+        recordsStageKey: step.recordsStageKey ?? step.stageKey,
+        recordSourceStageKey: step.recordSourceStageKey ?? step.recordsStageKey ?? step.stageKey,
         dependencyMode: step.dependencyMode,
         capabilityKey: step.capabilityKey,
         defaultBatchSize: step.defaultBatchSize,
         maxBatchSize: step.maxBatchSize
-      }
-
-      if (step.description) snapshotStep.description = step.description
-      if (step.dependsOn?.length) snapshotStep.dependsOn = [...step.dependsOn]
-
-      return snapshotStep
-    })
-  }
+      }
+
+      if (step.description) snapshotStep.description = step.description
+      if (step.recordEntity) snapshotStep.recordEntity = step.recordEntity
+      if (step.dependsOn?.length) snapshotStep.dependsOn = [...step.dependsOn]
+      if (step.credentialRequirements?.length) {
+        snapshotStep.credentialRequirements = step.credentialRequirements.map((requirement) => ({ ...requirement }))
+      }
+      if (step.recordColumns) {
+        snapshotStep.recordColumns = {
+          ...(step.recordColumns.company ? { company: step.recordColumns.company.map((column) => ({ ...column })) } : {}),
+          ...(step.recordColumns.contact ? { contact: step.recordColumns.contact.map((column) => ({ ...column })) } : {})
+        }
+      }
+
+      return snapshotStep
+    })
+  }
 }

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

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

package/src/business/acquisition/types.ts

@@ -1,5 +1,5 @@
 import type { Database } from '../../supabase/database.types'
-import type { CAPABILITY_REGISTRY } from '../../organization-model/domains/prospecting'
+import type { Capability, CredentialRequirement, RecordColumnConfig } from '../../organization-model/domains/prospecting'
 import type { LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
 import type { PipelineStage, ProcessingStageStatus } from './api-schemas'
 
@@ -52,7 +52,7 @@ export interface WebPost {
 }
 
 export type LeadGenStageKey = (typeof LEAD_GEN_STAGE_CATALOG)[keyof typeof LEAD_GEN_STAGE_CATALOG]['key']
-export type LeadGenCapabilityKey = keyof typeof CAPABILITY_REGISTRY
+export type LeadGenCapabilityKey = Capability['id']
 
 export interface ProcessingStateEntry {
   status: ProcessingStageStatus
@@ -167,11 +167,16 @@ export interface BuildPlanSnapshotStep {
   primaryEntity: BuildPlanSnapshotPrimaryEntity
   outputs: BuildPlanSnapshotOutput[]
   stageKey: string
+  recordEntity?: BuildPlanSnapshotPrimaryEntity
+  recordsStageKey?: string
+  recordSourceStageKey?: string
   dependsOn?: string[]
   dependencyMode: BuildPlanSnapshotDependencyMode
   capabilityKey: string
   defaultBatchSize: number
   maxBatchSize: number
+  recordColumns?: Partial<Record<BuildPlanSnapshotPrimaryEntity, RecordColumnConfig[]>>
+  credentialRequirements?: CredentialRequirement[]
 }
 
 export interface BuildPlanSnapshot {

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

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