@elevasis/core 0.14.0 → 0.15.1

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
@@ -92,6 +95,14 @@ export const TransitionItemRequestSchema = z
   })
   .strict()
 
+export const TransitionDealStateRequestSchema = z
+  .object({
+    stateKey: z.string().min(1),
+    reason: z.string().optional(),
+    expectedUpdatedAt: z.string().datetime().optional()
+  })
+  .strict()
+
 export const ExecuteActionParamsSchema = z
   .object({
     dealId: UuidSchema,
@@ -137,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.
@@ -164,11 +185,14 @@ export const DealListItemSchema = z.object({
   monthly_fee: z.number().nullable(),
   closed_lost_at: z.string().nullable(),
   closed_lost_reason: z.string().nullable(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  // joined relation
-  contact: DealContactSummarySchema.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()
+})
 
 export const DealListResponseSchema = z.object({
   data: z.array(DealListItemSchema),
@@ -217,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).
@@ -278,13 +318,16 @@ export const DealSchemas = {
   CreateDealNoteRequest: CreateDealNoteRequestSchema,
   CreateDealTaskRequest: CreateDealTaskRequestSchema,
   TransitionItemRequest: TransitionItemRequestSchema,
+  TransitionDealStateRequest: TransitionDealStateRequestSchema,
   ExecuteActionParams: ExecuteActionParamsSchema,
   ExecuteActionRequest: ExecuteActionRequestSchema,
 
   // Responses
+  DealPriority: DealPrioritySchema,
   DealListResponse: DealListResponseSchema,
   DealSummaryResponse: DealSummaryResponseSchema,
   DealLookupResponse: DealLookupResponseSchema,
+  ConversationMessage: ConversationMessageSchema,
   DealDetailResponse: DealDetailResponseSchema,
   DealNoteResponse: DealNoteResponseSchema,
   DealNoteListResponse: DealNoteListResponseSchema,
@@ -306,12 +349,15 @@ 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 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>
@@ -389,11 +435,53 @@ 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
 // ---------------------------------------------------------------------------
 
 export const ListStageCountsSchema = z.object({
+  // Attempted counts by canonical lead-gen stage. The detailed status
+  // distribution lives on ListProgress; telemetry keeps the overview payload small.
   stageCounts: z.object({
     populated: z.number().int(),
     extracted: z.number().int(),
@@ -438,6 +526,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()
@@ -448,11 +537,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']
   })
 
 /**
@@ -519,12 +621,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(),
@@ -542,20 +643,34 @@ export const ListTelemetryResponseSchema = ListTelemetrySchema
 
 export const ListTelemetryListResponseSchema = z.array(ListTelemetrySchema)
 
+/**
+ * Terminal row-level status for one lead-gen processing stage.
+ * Missing key still means not attempted; legacy boolean `true` is normalized
+ * to `success` by the API reader during rollout.
+ */
+export const ProcessingStageStatusSchema = z.enum(['success', 'no_result', 'skipped', 'error'])
+
 /**
  * Per-stage progress aggregate for a single pipeline stage.
- * `done` = count of members/companies where `(processing_state->>'<key>')::boolean` is true.
+ * `attempted` counts terminal statuses, including success, no-result, skipped,
+ * error, and tolerant-reader `other` values.
  * `total` = total member/company count for the list.
  */
 export const ListStageProgressSchema = z.object({
-  done: z.number().int().min(0),
-  total: z.number().int().min(0)
+  total: z.number().int().min(0),
+  attempted: z.number().int().min(0),
+  success: z.number().int().min(0),
+  noResult: z.number().int().min(0),
+  skipped: z.number().int().min(0),
+  error: z.number().int().min(0),
+  other: z.number().int().min(0),
+  notAttempted: z.number().int().min(0)
 })
 
 /**
  * Progress response for GET /acquisition/lists/:listId/progress.
- * Aggregated on-demand via COUNT(*) FILTER over processing_state flags (Decision #4).
- * `byStage` keys are driven by the list's pipeline_config.stages[].key.
+ * Aggregated on-demand from processing_state status values.
+ * Stage keys are discovered from observed processing_state keys.
  */
 export const ListProgressResponseSchema = z.object({
   totalMembers: z.number().int().min(0),
@@ -979,6 +1094,10 @@ export const AcqListSchemas = {
   IcpRubric: IcpRubricSchema,
   PipelineConfig: PipelineConfigSchema,
   PipelineStage: PipelineStageSchema,
+  BuildPlanSnapshot: BuildPlanSnapshotSchema,
+  BuildPlanSnapshotStep: BuildPlanSnapshotStepSchema,
+  AcqListMetadata: AcqListMetadataSchema,
+  ProcessingStageStatus: ProcessingStageStatusSchema,
   ListStageCounts: ListStageCountsSchema,
   ListTelemetry: ListTelemetrySchema,
 
@@ -1054,6 +1173,10 @@ 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>
 export type ListIdParams = z.infer<typeof ListIdParamsSchema>

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
+    })
+  }
+}

package/src/business/acquisition/crm-next-action.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect } from 'vitest'
+import { evaluateCrmDealNextAction, resolveCrmNextActionRuleConfig } from './crm-next-action'
+import { DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG } from '../../organization-model/domains/sales'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEvent(type: string, timestamp: string): Record<string, unknown> {
+  return { type, timestamp }
+}
+
+const INBOUND = 'reply_received'
+const OUTBOUND = 'reply_sent_to_lead'
+
+// ---------------------------------------------------------------------------
+// Closed deals → null
+// ---------------------------------------------------------------------------
+
+describe('evaluateCrmDealNextAction — closed deals', () => {
+  it('returns null for closed_won regardless of activity', () => {
+    expect(
+      evaluateCrmDealNextAction({
+        stage_key: 'interested',
+        state_key: 'closed_won',
+        activity_log: [makeEvent(INBOUND, '2026-01-10T10:00:00Z')]
+      })
+    ).toBeNull()
+  })
+
+  it('returns null for closed_lost regardless of activity', () => {
+    expect(
+      evaluateCrmDealNextAction({
+        stage_key: 'interested',
+        state_key: 'closed_lost',
+        activity_log: [makeEvent(INBOUND, '2026-01-10T10:00:00Z')]
+      })
+    ).toBeNull()
+  })
+
+  it('returns null for closed stages even when state_key is still actionable', () => {
+    expect(
+      evaluateCrmDealNextAction({
+        stage_key: 'closed_won',
+        state_key: 'discovery_replied',
+        activity_log: [makeEvent(INBOUND, '2026-01-10T10:00:00Z')]
+      })
+    ).toBeNull()
+  })
+
+  it('returns null when activity_log is empty (ownership null)', () => {
+    expect(
+      evaluateCrmDealNextAction({
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        activity_log: []
+      })
+    ).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// (state_key, ownership) mapping table
+// ---------------------------------------------------------------------------
+
+describe('evaluateCrmDealNextAction — mapping table', () => {
+  it('(discovery_replied, us) → send_reply', () => {
+    const result = evaluateCrmDealNextAction({
+      stage_key: 'interested',
+      state_key: 'discovery_replied',
+      activity_log: [makeEvent(INBOUND, '2026-04-20T10:00:00Z')]
+    })
+    expect(result).toBe('send_reply')
+  })
+
+  it('(discovery_nudging, them) → send_nudge', () => {
+    const result = evaluateCrmDealNextAction({
+      stage_key: 'interested',
+      state_key: 'discovery_nudging',
+      activity_log: [makeEvent(OUTBOUND, '2026-04-20T10:00:00Z')]
+    })
+    expect(result).toBe('send_nudge')
+  })
+
+  it('(discovery_link_sent, them) → send_nudge only after staleAfterDays', () => {
+    const recentActivity = '2026-04-29T10:00:00Z'
+    const now = new Date('2026-04-30T10:00:00Z')
+
+    // Age = 1 day — below staleAfterDays (14), no mapping fires → null fallback
+    // ownership === 'them' and no stale match → falls through to null
+    const notStale = evaluateCrmDealNextAction(
+      {
+        stage_key: 'interested',
+        state_key: 'discovery_link_sent',
+        activity_log: [makeEvent(OUTBOUND, recentActivity)]
+      },
+      { now }
+    )
+    expect(notStale).toBeNull()
+  })
+
+  it('(discovery_link_sent, them) → send_nudge when age >= staleAfterDays', () => {
+    const oldActivity = '2026-04-01T10:00:00Z'
+    const now = new Date('2026-04-30T10:00:00Z') // 29 days later
+
+    const stale = evaluateCrmDealNextAction(
+      {
+        stage_key: 'interested',
+        state_key: 'discovery_link_sent',
+        activity_log: [makeEvent(OUTBOUND, oldActivity)]
+      },
+      { now }
+    )
+    expect(stale).toBe('send_nudge')
+  })
+
+  it('(*, us) → ownershipUsFallback send_reply when no explicit mapping matches', () => {
+    // reply_sent + inbound → ownership=us, state_key not in explicit mappings
+    const result = evaluateCrmDealNextAction({
+      stage_key: 'interested',
+      state_key: 'reply_sent',
+      activity_log: [makeEvent(INBOUND, '2026-04-20T10:00:00Z')]
+    })
+    expect(result).toBe('send_reply')
+  })
+
+  it('(followup_1_sent, us) → send_reply via fallback', () => {
+    const result = evaluateCrmDealNextAction({
+      stage_key: 'interested',
+      state_key: 'followup_1_sent',
+      activity_log: [makeEvent(INBOUND, '2026-04-20T10:00:00Z')]
+    })
+    expect(result).toBe('send_reply')
+  })
+
+  it('returns null when ownership is them and no mapping matches and not stale', () => {
+    const result = evaluateCrmDealNextAction({
+      stage_key: 'interested',
+      state_key: 'followup_2_sent',
+      activity_log: [makeEvent(OUTBOUND, '2026-04-29T10:00:00Z')]
+    })
+    expect(result).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ageDays option
+// ---------------------------------------------------------------------------
+
+describe('evaluateCrmDealNextAction — ageDays option', () => {
+  it('uses supplied ageDays instead of computing from activity_log', () => {
+    // discovery_link_sent + them + ageDays=20 (>=14) → send_nudge
+    const result = evaluateCrmDealNextAction(
+      {
+        stage_key: 'interested',
+        state_key: 'discovery_link_sent',
+        activity_log: [makeEvent(OUTBOUND, '2026-04-29T10:00:00Z')]
+      },
+      { ageDays: 20 }
+    )
+    expect(result).toBe('send_nudge')
+  })
+
+  it('requiresStale blocks when ageDays=0', () => {
+    const result = evaluateCrmDealNextAction(
+      {
+        stage_key: 'interested',
+        state_key: 'discovery_link_sent',
+        activity_log: [makeEvent(OUTBOUND, '2026-04-29T10:00:00Z')]
+      },
+      { ageDays: 0 }
+    )
+    expect(result).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveCrmNextActionRuleConfig — defaults
+// ---------------------------------------------------------------------------
+
+describe('resolveCrmNextActionRuleConfig — defaults', () => {
+  it('returns default config when called with no input', () => {
+    const config = resolveCrmNextActionRuleConfig()
+    expect(config.ownershipUsFallback).toBe(DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG.ownershipUsFallback)
+    expect(config.mappings).toHaveLength(DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG.mappings.length)
+  })
+
+  it('returns default config for invalid input', () => {
+    const config = resolveCrmNextActionRuleConfig('not-an-object')
+    expect(config.ownershipUsFallback).toBe(DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG.ownershipUsFallback)
+  })
+
+  it('accepts a full CrmNextActionRuleConfig directly', () => {
+    const full = {
+      mappings: [{ stateKey: 'foo', ownership: 'us' as const, actionKey: 'bar' }],
+      ownershipUsFallback: 'bar'
+    }
+    const config = resolveCrmNextActionRuleConfig(full)
+    expect(config.ownershipUsFallback).toBe('bar')
+    expect(config.mappings).toHaveLength(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Per-org override merging
+// ---------------------------------------------------------------------------
+
+describe('resolveCrmNextActionRuleConfig — per-org override', () => {
+  it('prepends org mappings before defaults (org rules win on first-match)', () => {
+    const orgConfig = {
+      crm: {
+        next_actions: {
+          mappings: [{ stateKey: 'discovery_replied', ownership: 'us' as const, actionKey: 'custom_action' }]
+        }
+      }
+    }
+    const config = resolveCrmNextActionRuleConfig(orgConfig)
+    // Org mapping should appear first
+    expect(config.mappings[0].actionKey).toBe('custom_action')
+    // Default mappings still present after org ones
+    expect(config.mappings.length).toBeGreaterThan(1)
+  })
+
+  it('overrides ownershipUsFallback when supplied', () => {
+    const orgConfig = {
+      crm: {
+        next_actions: {
+          ownershipUsFallback: 'org_custom_reply'
+        }
+      }
+    }
+    const config = resolveCrmNextActionRuleConfig(orgConfig)
+    expect(config.ownershipUsFallback).toBe('org_custom_reply')
+  })
+
+  it('org override fires over default for same (state_key, ownership) pair', () => {
+    // Org remaps (discovery_replied, us) → 'org_reply'
+    const result = evaluateCrmDealNextAction(
+      {
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        activity_log: [makeEvent(INBOUND, '2026-04-20T10:00:00Z')]
+      },
+      {
+        config: {
+          crm: {
+            next_actions: {
+              mappings: [{ stateKey: 'discovery_replied', ownership: 'us', actionKey: 'org_reply' }]
+            }
+          }
+        }
+      }
+    )
+    expect(result).toBe('org_reply')
+  })
+
+  it('falls back to defaults when org override is empty object', () => {
+    const config = resolveCrmNextActionRuleConfig({ crm: { next_actions: {} } })
+    expect(config.mappings).toHaveLength(DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG.mappings.length)
+    expect(config.ownershipUsFallback).toBe(DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG.ownershipUsFallback)
+  })
+})