@elevasis/core 0.15.0 → 0.16.0

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

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { LEAD_GEN_PIPELINE_DEFINITIONS, LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
+import {
+  DEFAULT_CRM_PRIORITY_RULE_CONFIG,
+  LEAD_GEN_PIPELINE_DEFINITIONS,
+  LEAD_GEN_STAGE_CATALOG
+} from '../../organization-model/domains/sales'
+import { CrmPriorityOverrideSchema, evaluateCrmDealPriority, resolveCrmPriorityRuleConfig } from './crm-priority'
 import {
   AddCompaniesToListRequestSchema,
   AddContactsToListRequestSchema,
@@ -15,6 +20,7 @@ import {
   CreateDealTaskRequestSchema,
   CreateListRequestSchema,
   DealDetailResponseSchema,
+  DealListItemSchema,
   DealListResponseSchema,
   DealNoteResponseSchema,
   DealStageSchema,
@@ -44,6 +50,15 @@ import {
 
 const VALID_UUID = '00000000-0000-4000-8000-000000000001'
 const ISO_TS = '2026-04-27T12:34:56.000Z'
+const PRIORITY = {
+  bucketKey: 'waiting' as const,
+  rank: 30,
+  label: 'Waiting',
+  color: 'blue',
+  reason: 'No immediate response or follow-up is due.',
+  latestActivityAt: ISO_TS,
+  nextActionAt: null
+}
 
 // ---------------------------------------------------------------------------
 // DealStageSchema
@@ -414,10 +429,251 @@ describe('UpdateContactRequestSchema', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// CRM priority override contract
+// ---------------------------------------------------------------------------
+
+describe('CrmPriorityOverrideSchema', () => {
+  it('accepts a valid partial organization override', () => {
+    const result = CrmPriorityOverrideSchema.safeParse({
+      enabled: true,
+      staleAfterDays: 10,
+      bucketOrder: ['needs_response', 'follow_up_due', 'stale', 'waiting', 'closed_low'],
+      buckets: {
+        needs_response: { label: 'Reply Now', color: 'red', rank: 5 },
+        waiting: { label: 'Pending' }
+      },
+      followUpAfterDaysByStateKey: {
+        discovery_link_sent: 2,
+        custom_state: 4
+      },
+      closedStageKeys: ['closed_won', 'closed_lost']
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects needsResponseStateKeys and needsResponseActivityTypes (removed fields)', () => {
+    expect(CrmPriorityOverrideSchema.safeParse({ needsResponseStateKeys: ['x'] }).success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ needsResponseActivityTypes: ['x'] }).success).toBe(false)
+  })
+
+  it('accepts sparse partial overrides', () => {
+    const result = CrmPriorityOverrideSchema.safeParse({
+      staleAfterDays: 21,
+      buckets: {
+        stale: { color: 'yellow' }
+      }
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects invalid unknown input shapes', () => {
+    expect(CrmPriorityOverrideSchema.safeParse('bad').success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ staleAfterDays: -1 }).success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ buckets: { invalid_bucket: { label: 'Bad' } } }).success).toBe(false)
+  })
+})
+
+describe('resolveCrmPriorityRuleConfig', () => {
+  it('merges valid organization config overrides with default rules', () => {
+    const resolved = resolveCrmPriorityRuleConfig({
+      crm: {
+        priority: {
+          staleAfterDays: 7,
+          bucketOrder: ['stale', 'needs_response'],
+          buckets: {
+            stale: { label: 'Dormant', color: 'yellow' },
+            needs_response: { rank: 3 }
+          },
+          followUpAfterDaysByStateKey: { discovery_link_sent: 1 },
+          closedStageKeys: ['won', 'lost']
+        }
+      }
+    })
+
+    expect(resolved.enabled).toBe(true)
+    expect(resolved.staleAfterDays).toBe(7)
+    expect(resolved.closedStageKeys).toEqual(['won', 'lost'])
+    expect(resolved.followUpAfterDaysByStateKey.discovery_link_sent).toBe(1)
+    expect(resolved.followUpAfterDaysByStateKey.reply_sent).toBe(
+      DEFAULT_CRM_PRIORITY_RULE_CONFIG.followUpAfterDaysByStateKey.reply_sent
+    )
+
+    const staleBucket = resolved.buckets.find((bucket) => bucket.bucketKey === 'stale')
+    expect(staleBucket).toMatchObject({ label: 'Dormant', color: 'yellow', rank: 10 })
+
+    const needsResponseBucket = resolved.buckets.find((bucket) => bucket.bucketKey === 'needs_response')
+    expect(needsResponseBucket?.rank).toBe(3)
+  })
+
+  it('falls back to defaults for missing or invalid input', () => {
+    expect(resolveCrmPriorityRuleConfig(undefined)).toMatchObject({
+      enabled: true,
+      staleAfterDays: DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays,
+      closedStageKeys: DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys
+    })
+
+    expect(resolveCrmPriorityRuleConfig({ staleAfterDays: 0 })).toMatchObject({
+      enabled: true,
+      staleAfterDays: DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays,
+      closedStageKeys: DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys
+    })
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Response schemas — smoke-level forward-compat checks
 // ---------------------------------------------------------------------------
 
+describe('evaluateCrmDealPriority', () => {
+  const now = '2026-04-30T12:00:00.000Z'
+  const baseInput = {
+    stage_key: 'interested',
+    state_key: null,
+    activity_log: [],
+    updated_at: '2026-04-29T12:00:00.000Z',
+    created_at: '2026-04-01T12:00:00.000Z'
+  }
+
+  it('returns needs_response when the lead replied last (ownership us)', () => {
+    // A reply_received inbound event makes ownership === 'us' → needs_response
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_replied',
+        activity_log: [{ type: 'reply_received', timestamp: '2026-04-29T10:00:00.000Z' }]
+      },
+      { now }
+    )
+    expect(priority.bucketKey).toBe('needs_response')
+    expect(priority.rank).toBe(10)
+    expect(priority.reason).toBe('Lead replied last — we owe the next move.')
+  })
+
+  it('returns follow_up_due when configured follow-up window has elapsed', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_link_sent',
+        activity_log: [{ type: 'action_taken', timestamp: '2026-04-25T12:00:00.000Z', actionKey: 'send_link' }],
+        updated_at: '2026-04-25T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('follow_up_due')
+    expect(priority.nextActionAt).toBe('2026-04-28T12:00:00.000Z')
+  })
+
+  it('returns waiting when the next action is still in the future', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_link_sent',
+        activity_log: [{ type: 'action_taken', timestamp: '2026-04-29T12:00:00.000Z', actionKey: 'send_link' }],
+        updated_at: '2026-04-29T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('waiting')
+    expect(priority.nextActionAt).toBe('2026-05-02T12:00:00.000Z')
+  })
+
+  it('returns stale when there is no recent meaningful activity', () => {
+    const priority = evaluateCrmDealPriority(
+      { ...baseInput, updated_at: '2026-04-01T12:00:00.000Z', created_at: '2026-04-01T12:00:00.000Z' },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('stale')
+  })
+
+  it('returns closed_low for closed stages', () => {
+    const priority = evaluateCrmDealPriority({ ...baseInput, stage_key: 'closed_lost' }, { now })
+    expect(priority.bucketKey).toBe('closed_low')
+    expect(priority.rank).toBe(50)
+  })
+
+  it('ignores malformed activity entries without throwing', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        activity_log: [null, 'bad', { type: 'reply_received', timestamp: 'not-a-date' }, { other: true }],
+        updated_at: '2026-04-29T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('waiting')
+    expect(priority.latestActivityAt).toBe('2026-04-29T12:00:00.000Z')
+  })
+
+  it('returns a neutral waiting priority when CRM priority is disabled', () => {
+    const config = resolveCrmPriorityRuleConfig({
+      enabled: false,
+      buckets: {
+        waiting: { label: 'Priority Off', color: 'gray', rank: 999 }
+      }
+    })
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_replied',
+        activity_log: [{ type: 'reply_received', timestamp: '2026-04-30T10:00:00.000Z' }]
+      },
+      { config, now }
+    )
+
+    expect(priority).toMatchObject({
+      bucketKey: 'waiting',
+      label: 'Priority Off',
+      color: 'gray',
+      rank: 999,
+      reason: 'CRM priority evaluation is disabled.',
+      nextActionAt: null
+    })
+  })
+})
+
+describe('DealListItemSchema', () => {
+  it('accepts a deal with a derived priority object', () => {
+    const result = DealListItemSchema.safeParse({
+      id: VALID_UUID,
+      organization_id: VALID_UUID,
+      contact_id: null,
+      contact_email: 'test@example.com',
+      pipeline_key: 'crm',
+      stage_key: 'interested',
+      state_key: 'discovery_link_sent',
+      activity_log: [],
+      discovery_data: null,
+      discovery_submitted_at: null,
+      discovery_submitted_by: null,
+      proposal_data: null,
+      proposal_sent_at: null,
+      proposal_pdf_url: null,
+      signature_envelope_id: null,
+      source_list_id: null,
+      source_type: null,
+      initial_fee: null,
+      monthly_fee: null,
+      closed_lost_at: null,
+      closed_lost_reason: null,
+      created_at: ISO_TS,
+      updated_at: ISO_TS,
+      priority: PRIORITY,
+      ownership: null,
+      nextAction: null,
+      contact: null
+    })
+
+    expect(result.success).toBe(true)
+  })
+})
+
 describe('DealDetailResponseSchema (forward-compat)', () => {
   const baseDeal = {
     id: VALID_UUID,
@@ -443,13 +699,39 @@ describe('DealDetailResponseSchema (forward-compat)', () => {
     closed_lost_reason: null,
     created_at: ISO_TS,
     updated_at: ISO_TS,
-    contact: null
+    priority: PRIORITY,
+    ownership: null,
+    nextAction: null,
+    contact: null,
+    conversation: {
+      messages: []
+    }
   }
 
-  it('accepts a deal with null contact', () => {
+  it('accepts a deal with null contact and an empty conversation', () => {
     expect(DealDetailResponseSchema.safeParse(baseDeal).success).toBe(true)
   })
 
+  it('accepts conversation messages with preview-derived bodies', () => {
+    const withConversation = {
+      ...baseDeal,
+      conversation: {
+        messages: [
+          {
+            id: 'message-1',
+            direction: 'inbound',
+            fromEmail: 'lead@example.com',
+            toEmail: 'sender@example.com',
+            subject: 'Re: quick thought',
+            body: 'Sure, send it over.',
+            sentAt: ISO_TS
+          }
+        ]
+      }
+    }
+    expect(DealDetailResponseSchema.safeParse(withConversation).success).toBe(true)
+  })
+
   it('accepts a deal with nested contact that has null company', () => {
     const withContact = {
       ...baseDeal,
@@ -668,6 +950,19 @@ describe('CreateListRequestSchema', () => {
     expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'draft' }).success).toBe(true)
   })
 
+  it('accepts a known prospecting build template id', () => {
+    const result = CreateListRequestSchema.safeParse({
+      name: 'DTC Subscription Brands',
+      buildTemplateId: 'dtc-subscription-apollo-clickup'
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an unknown prospecting build template id', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'X', buildTemplateId: 'not-a-template' }).success).toBe(false)
+  })
+
   it('rejects an invalid status', () => {
     expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'active' }).success).toBe(false)
   })
@@ -710,6 +1005,23 @@ describe('UpdateListRequestSchema', () => {
     expect(UpdateListRequestSchema.safeParse({ batchIds: ['batch-1'] }).success).toBe(true)
   })
 
+  it('accepts buildTemplateId when the change is explicitly confirmed', () => {
+    expect(
+      UpdateListRequestSchema.safeParse({
+        buildTemplateId: 'dtc-subscription-apollo-clickup',
+        confirmBuildTemplateChange: true
+      }).success
+    ).toBe(true)
+  })
+
+  it('rejects buildTemplateId without explicit confirmation', () => {
+    expect(
+      UpdateListRequestSchema.safeParse({
+        buildTemplateId: 'dtc-subscription-apollo-clickup'
+      }).success
+    ).toBe(false)
+  })
+
   it('rejects unknown fields (strict mode)', () => {
     expect(UpdateListRequestSchema.safeParse({ name: 'X', extra: 'bad' }).success).toBe(false)
   })
@@ -1115,7 +1427,6 @@ describe('AcqListResponseSchema (forward-compat)', () => {
     organizationId: VALID_UUID,
     name: 'Test List',
     description: null,
-    type: 'standard',
     batchIds: [],
     instantlyCampaignId: null,
     status: 'draft' as const,

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

@@ -1,6 +1,9 @@
 import { z } from 'zod'
 import { UuidSchema, NonEmptyStringSchema } from '../../platform/utils/validation'
 import { LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
+import { isProspectingBuildTemplateId } from './build-templates'
+export { CrmPriorityBucketKeySchema, CrmPriorityBucketOverrideSchema, CrmPriorityOverrideSchema } from './crm-priority'
+export type { CrmPriorityBucketOverride, CrmPriorityOverride, ResolvedCrmPriorityRuleConfig } from './crm-priority'
 
 /**
  * Deal Management API Schemas
@@ -145,6 +148,16 @@ export const DealContactSummarySchema = z.object({
     .nullable()
 })
 
+export const DealPrioritySchema = z.object({
+  bucketKey: z.enum(['needs_response', 'follow_up_due', 'waiting', 'stale', 'closed_low']),
+  rank: z.number().int(),
+  label: z.string(),
+  color: z.string(),
+  reason: z.string(),
+  latestActivityAt: z.string().nullable(),
+  nextActionAt: z.string().nullable()
+})
+
 /**
  * Deal list item with joined contact (and company via contact).
  * Matches DealListItem from @repo/core types.
@@ -174,6 +187,9 @@ export const DealListItemSchema = z.object({
   closed_lost_reason: z.string().nullable(),
   created_at: z.string(),
   updated_at: z.string(),
+  priority: DealPrioritySchema,
+  ownership: z.enum(['us', 'them']).nullable(),
+  nextAction: z.string().nullable(),
   // joined relation
   contact: DealContactSummarySchema.nullable()
 })
@@ -225,11 +241,27 @@ export const DealLookupItemSchema = z.object({
 
 export const DealLookupResponseSchema = z.array(DealLookupItemSchema)
 
+export const ConversationMessageSchema = z.object({
+  id: z.string(),
+  direction: z.enum(['inbound', 'outbound']),
+  fromEmail: z.string(),
+  toEmail: z.string(),
+  subject: z.string().nullable(),
+  body: z.string(),
+  sentAt: z.string().nullable()
+})
+
+export const DealConversationSchema = z.object({
+  messages: z.array(ConversationMessageSchema)
+})
+
 /**
  * Deal detail shape — currently the same as a list item (full joined record).
- * useDealDetail returns DealDetail which is typed as DealListItem.
+ * Additive fields keep existing DealListItem callers compatible.
  */
-export const DealDetailResponseSchema = DealListItemSchema
+export const DealDetailResponseSchema = DealListItemSchema.extend({
+  conversation: DealConversationSchema
+})
 
 /**
  * Single acq_deal_notes row (camelCase API representation).
@@ -291,9 +323,11 @@ export const DealSchemas = {
   ExecuteActionRequest: ExecuteActionRequestSchema,
 
   // Responses
+  DealPriority: DealPrioritySchema,
   DealListResponse: DealListResponseSchema,
   DealSummaryResponse: DealSummaryResponseSchema,
   DealLookupResponse: DealLookupResponseSchema,
+  ConversationMessage: ConversationMessageSchema,
   DealDetailResponse: DealDetailResponseSchema,
   DealNoteResponse: DealNoteResponseSchema,
   DealNoteListResponse: DealNoteListResponseSchema,
@@ -318,10 +352,12 @@ export type TransitionItemRequest = z.infer<typeof TransitionItemRequestSchema>
 export type TransitionDealStateRequest = z.infer<typeof TransitionDealStateRequestSchema>
 export type ExecuteActionParams = z.infer<typeof ExecuteActionParamsSchema>
 export type ExecuteActionRequest = z.infer<typeof ExecuteActionRequestSchema>
+export type DealPriorityResponse = z.infer<typeof DealPrioritySchema>
 export type DealListResponse = z.infer<typeof DealListResponseSchema>
 export type DealSummaryResponse = z.infer<typeof DealSummaryResponseSchema>
 export type DealLookupItem = z.infer<typeof DealLookupItemSchema>
 export type DealLookupResponse = z.infer<typeof DealLookupResponseSchema>
+export type ConversationMessage = z.infer<typeof ConversationMessageSchema>
 export type DealDetailResponse = z.infer<typeof DealDetailResponseSchema>
 export type DealNoteResponse = z.infer<typeof DealNoteResponseSchema>
 export type DealNoteListResponse = z.infer<typeof DealNoteListResponseSchema>
@@ -399,6 +435,41 @@ export const PipelineConfigSchema = z.object({
   stages: z.array(PipelineStageSchema).optional()
 })
 
+export const BuildPlanSnapshotStepSchema = z
+  .object({
+    id: z.string().trim().min(1).max(100),
+    label: z.string().trim().min(1).max(120),
+    description: z.string().trim().min(1).max(2000).optional(),
+    primaryEntity: z.enum(['company', 'contact']),
+    outputs: z.array(z.enum(['company', 'contact', 'export'])).min(1),
+    stageKey: z.string().trim().min(1).max(100),
+    dependsOn: z.array(z.string().trim().min(1).max(100)).optional(),
+    dependencyMode: z.literal('per-record-eligibility'),
+    capabilityKey: z.string().trim().min(1).max(100),
+    defaultBatchSize: z.number().int().positive(),
+    maxBatchSize: z.number().int().positive()
+  })
+  .refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+    message: 'defaultBatchSize must be less than or equal to maxBatchSize',
+    path: ['defaultBatchSize']
+  })
+
+export const BuildPlanSnapshotSchema = z.object({
+  templateId: z.string().trim().min(1).max(100),
+  templateLabel: z.string().trim().min(1).max(120),
+  steps: z.array(BuildPlanSnapshotStepSchema).min(1)
+})
+
+export const AcqListMetadataSchema = z
+  .object({
+    buildPlanSnapshot: BuildPlanSnapshotSchema.optional()
+  })
+  .catchall(z.unknown())
+
+export const ProspectingBuildTemplateIdSchema = z.string().trim().min(1).max(100).refine(isProspectingBuildTemplateId, {
+  message: 'buildTemplateId must match a known prospecting build template'
+})
+
 // ---------------------------------------------------------------------------
 // List telemetry / progress schemas
 // ---------------------------------------------------------------------------
@@ -450,6 +521,7 @@ export const CreateListRequestSchema = z
     name: z.string().trim().min(1).max(255),
     description: z.string().trim().nullable().optional(),
     status: ListStatusSchema.optional(),
+    buildTemplateId: ProspectingBuildTemplateIdSchema.optional(),
     scrapingConfig: ScrapingConfigSchema.optional(),
     icp: IcpRubricSchema.optional(),
     pipelineConfig: PipelineConfigSchema.optional()
@@ -460,11 +532,24 @@ export const UpdateListRequestSchema = z
   .object({
     name: z.string().trim().min(1).max(255).optional(),
     description: z.string().trim().nullable().optional(),
-    batchIds: z.array(z.string()).optional()
+    batchIds: z.array(z.string()).optional(),
+    buildTemplateId: ProspectingBuildTemplateIdSchema.optional(),
+    confirmBuildTemplateChange: z.literal(true).optional()
   })
   .strict()
-  .refine((data) => data.name !== undefined || data.description !== undefined || data.batchIds !== undefined, {
-    message: 'At least one field (name, description, or batchIds) must be provided'
+  .refine(
+    (data) =>
+      data.name !== undefined ||
+      data.description !== undefined ||
+      data.batchIds !== undefined ||
+      data.buildTemplateId !== undefined,
+    {
+      message: 'At least one field (name, description, batchIds, or buildTemplateId) must be provided'
+    }
+  )
+  .refine((data) => data.buildTemplateId === undefined || data.confirmBuildTemplateChange === true, {
+    message: 'confirmBuildTemplateChange must be true when changing buildTemplateId',
+    path: ['confirmBuildTemplateChange']
   })
 
 /**
@@ -531,12 +616,11 @@ export const AcqListResponseSchema = z.object({
   organizationId: z.string(),
   name: z.string(),
   description: z.string().nullable(),
-  type: z.string(),
   batchIds: z.array(z.string()),
   instantlyCampaignId: z.string().nullable(),
   /** Lifecycle status (draft | enriching | launched | closing | archived). */
   status: ListStatusSchema,
-  metadata: z.record(z.string(), z.unknown()),
+  metadata: AcqListMetadataSchema,
   launchedAt: z.string().nullable(),
   completedAt: z.string().nullable(),
   createdAt: z.string(),
@@ -600,7 +684,8 @@ export const ListExecutionSummarySchema = z.object({
   status: z.string(),
   createdAt: z.string(),
   completedAt: z.string().nullable(),
-  durationMs: z.number().int().nullable()
+  durationMs: z.number().int().nullable(),
+  input: z.unknown().nullable().optional()
 })
 
 export const ListExecutionsResponseSchema = z.array(ListExecutionSummarySchema)
@@ -619,6 +704,29 @@ export const AcqCompanyStatusSchema = z.enum(['active', 'invalid'])
 export const AcqContactStatusSchema = z.enum(['active', 'invalid'])
 export const AcqEmailValidSchema = z.enum(['VALID', 'INVALID', 'RISKY', 'UNKNOWN'])
 
+/**
+ * Zod schema mirroring the CompanyPipelineStatus interface from types.ts.
+ * Used by operations-layer CompanyRecord schemas to validate pipelineStatus
+ * against the canonical shape instead of using open passthrough().
+ */
+export const CompanyPipelineStatusSchema = z
+  .object({
+    acquired: z.boolean().optional(),
+    enrichment: z
+      .record(
+        z.string(),
+        z
+          .object({
+            status: z.enum(['pending', 'complete', 'failed', 'skipped']),
+            completedAt: z.string().optional(),
+            error: z.string().optional()
+          })
+          .passthrough()
+      )
+      .optional()
+  })
+  .passthrough()
+
 export const CompanyIdParamsSchema = z.object({
   companyId: UuidSchema
 })
@@ -1005,6 +1113,9 @@ export const AcqListSchemas = {
   IcpRubric: IcpRubricSchema,
   PipelineConfig: PipelineConfigSchema,
   PipelineStage: PipelineStageSchema,
+  BuildPlanSnapshot: BuildPlanSnapshotSchema,
+  BuildPlanSnapshotStep: BuildPlanSnapshotStepSchema,
+  AcqListMetadata: AcqListMetadataSchema,
   ProcessingStageStatus: ProcessingStageStatusSchema,
   ListStageCounts: ListStageCountsSchema,
   ListTelemetry: ListTelemetrySchema,
@@ -1081,6 +1192,9 @@ export type ScrapingConfig = z.infer<typeof ScrapingConfigSchema>
 export type IcpRubric = z.infer<typeof IcpRubricSchema>
 export type PipelineStage = z.infer<typeof PipelineStageSchema>
 export type PipelineConfig = z.infer<typeof PipelineConfigSchema>
+export type BuildPlanSnapshotStep = z.infer<typeof BuildPlanSnapshotStepSchema>
+export type BuildPlanSnapshot = z.infer<typeof BuildPlanSnapshotSchema>
+export type AcqListMetadata = z.infer<typeof AcqListMetadataSchema>
 export type ProcessingStageStatus = z.infer<typeof ProcessingStageStatusSchema>
 export type ListStageCountsInput = z.infer<typeof ListStageCountsSchema>['stageCounts']
 export type ListTelemetryInput = z.infer<typeof ListTelemetrySchema>

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

@@ -0,0 +1,44 @@
+import { DEFAULT_ORGANIZATION_MODEL_PROSPECTING } from '../../organization-model/domains/prospecting'
+import type { BuildPlanSnapshot, BuildPlanSnapshotStep } from './types'
+
+export const PROSPECTING_BUILD_TEMPLATE_OPTIONS = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates.map(
+  ({ id, label, description }) => ({
+    id,
+    label,
+    description
+  })
+)
+
+export const DEFAULT_PROSPECTING_BUILD_TEMPLATE_ID = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.defaultBuildTemplateId
+
+export function isProspectingBuildTemplateId(value: string): boolean {
+  return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value)
+}
+
+export function createBuildPlanSnapshotFromTemplateId(templateId: string): BuildPlanSnapshot | null {
+  const template = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates.find((item) => item.id === templateId)
+  if (!template) return null
+
+  return {
+    templateId: template.id,
+    templateLabel: template.label,
+    steps: template.steps.map((step): BuildPlanSnapshotStep => {
+      const snapshotStep: BuildPlanSnapshotStep = {
+        id: step.id,
+        label: step.label,
+        primaryEntity: step.primaryEntity,
+        outputs: [...step.outputs],
+        stageKey: 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
+    })
+  }
+}