@elevasis/core 0.14.0 → 0.15.1

package/src/business/acquisition/deal-ownership.test.ts

@@ -0,0 +1,351 @@
+import { describe, it, expect } from 'vitest'
+import { getDealOwnership } from './deal-ownership'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEvent(type: string, timestamp: string): Record<string, unknown> {
+  return { type, timestamp }
+}
+
+// ---------------------------------------------------------------------------
+// Closed deals
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — closed deals', () => {
+  it('returns null for closed_won regardless of activity_log', () => {
+    const deal = {
+      state_key: 'closed_won',
+      activity_log: [makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBeNull()
+  })
+
+  it('returns null for closed_lost regardless of activity_log', () => {
+    const deal = {
+      state_key: 'closed_lost',
+      activity_log: [makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Empty / missing activity log
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — empty activity log', () => {
+  it('returns null when activity_log is an empty array', () => {
+    expect(getDealOwnership({ state_key: 'discovery_replied', activity_log: [] })).toBeNull()
+  })
+
+  it('returns null when activity_log is null', () => {
+    expect(getDealOwnership({ state_key: 'discovery_replied', activity_log: null })).toBeNull()
+  })
+
+  it('returns null when activity_log is undefined', () => {
+    expect(getDealOwnership({ state_key: 'discovery_replied', activity_log: undefined })).toBeNull()
+  })
+
+  it('returns null when activity_log is a non-array value', () => {
+    expect(getDealOwnership({ state_key: 'discovery_replied', activity_log: 'bad' })).toBeNull()
+  })
+
+  it('returns null when activity_log contains no inbound or outbound events', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('deal_created', '2026-01-01T00:00:00Z'),
+        makeEvent('stage_change', '2026-01-02T00:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// us ownership (inbound is most recent)
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — us ownership', () => {
+  it('returns "us" when inbound event is newer than outbound event', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_received', '2026-01-11T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('returns "us" when only a reply_received event exists', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('returns "us" with mixed irrelevant events present', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('deal_created', '2026-01-01T00:00:00Z'),
+        makeEvent('reply_sent_to_lead', '2026-01-10T08:00:00Z'),
+        makeEvent('state_change', '2026-01-10T09:00:00Z'),
+        makeEvent('reply_received', '2026-01-10T12:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('returns "us" picking the latest of multiple inbound events', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_received', '2026-01-09T10:00:00Z'),
+        makeEvent('reply_received', '2026-01-11T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// them ownership (outbound is most recent or tied)
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — them ownership', () => {
+  it('returns "them" when outbound event is newer than inbound event', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('reply_received', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_sent_to_lead', '2026-01-11T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('returns "them" on exact timestamp tie (outbound wins tie-break)', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('reply_received', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('returns "them" when only outbound events exist', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [makeEvent('booking_nudge_sent', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('returns "them" for each outbound type independently', () => {
+    const outboundTypes = [
+      'reply_sent_to_lead',
+      'booking_nudge_sent',
+      'reminder_sent',
+      'rebook_sent',
+      'followup_email_sent',
+      'reply_followup_sent',
+      'lead_deferred_next_step'
+    ] as const
+
+    for (const type of outboundTypes) {
+      const deal = {
+        state_key: 'discovery_replied',
+        activity_log: [makeEvent(type, '2026-01-10T10:00:00Z')]
+      }
+      expect(getDealOwnership(deal), `expected "them" for outbound type: ${type}`).toBe('them')
+    }
+  })
+
+  it('returns "them" picking the latest of multiple outbound events', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        makeEvent('reply_received', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_sent_to_lead', '2026-01-09T10:00:00Z'),
+        makeEvent('booking_nudge_sent', '2026-01-11T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('treats canonical and legacy follow-up events as outbound ownership inputs', () => {
+    const canonical = {
+      state_key: 'followup_1_sent',
+      activity_log: [
+        makeEvent('reply_received', '2026-01-10T10:00:00Z'),
+        makeEvent('followup_email_sent', '2026-01-11T10:00:00Z')
+      ]
+    }
+    const legacy = {
+      state_key: 'followup_1_sent',
+      activity_log: [
+        makeEvent('reply_received', '2026-01-10T10:00:00Z'),
+        makeEvent('reply_followup_sent', '2026-01-11T10:00:00Z')
+      ]
+    }
+
+    expect(getDealOwnership(canonical)).toBe('them')
+    expect(getDealOwnership(legacy)).toBe('them')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Timestamp COALESCE — alternate timestamp field names
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — timestamp field coalesce', () => {
+  it('resolves timestamp from occurredAt field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        { type: 'reply_received', occurredAt: '2026-01-11T10:00:00Z' },
+        { type: 'reply_sent_to_lead', occurredAt: '2026-01-10T10:00:00Z' }
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('resolves timestamp from createdAt field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [{ type: 'reply_received', createdAt: '2026-01-10T10:00:00Z' }]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('resolves timestamp from updatedAt field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [{ type: 'reply_sent_to_lead', updatedAt: '2026-01-10T10:00:00Z' }]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('resolves timestamp from sentAt field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [{ type: 'reply_sent_to_lead', sentAt: '2026-01-10T10:00:00Z' }]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('prefers timestamp over occurredAt when both present', () => {
+    // outbound has timestamp=newer, inbound has occurredAt=older → "them"
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        { type: 'reply_received', timestamp: '2026-01-09T00:00:00Z', occurredAt: '2026-01-12T00:00:00Z' },
+        { type: 'reply_sent_to_lead', timestamp: '2026-01-10T00:00:00Z' }
+      ]
+    }
+    // inbound timestamp=Jan 9, outbound timestamp=Jan 10 → outbound newer → "them"
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Malformed entries — must be silently skipped
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — malformed events skipped', () => {
+  it('skips entries with no timestamp field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        { type: 'reply_received' }, // no timestamp
+        makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z')
+      ]
+    }
+    // Only the outbound event has a valid timestamp — result is "them"
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('skips entries with an invalid timestamp string', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        { type: 'reply_received', timestamp: 'not-a-date' },
+        makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('skips null entries in the array', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [null, makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('skips non-object entries in the array', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: ['string', 42, makeEvent('reply_sent_to_lead', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('skips array-in-array entries', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [[], makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('skips entries with missing type field', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [
+        { timestamp: '2026-01-10T10:00:00Z' }, // no type
+        makeEvent('reply_sent_to_lead', '2026-01-11T10:00:00Z')
+      ]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+
+  it('returns null when all entries are malformed', () => {
+    const deal = {
+      state_key: 'discovery_replied',
+      activity_log: [null, 'bad', { type: 'reply_received' }]
+    }
+    expect(getDealOwnership(deal)).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// state_key variants (non-closed)
+// ---------------------------------------------------------------------------
+
+describe('getDealOwnership — non-closed state_key variants', () => {
+  it('evaluates ownership for null state_key', () => {
+    const deal = {
+      state_key: null,
+      activity_log: [makeEvent('reply_received', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('us')
+  })
+
+  it('evaluates ownership for discovery_link_sent state', () => {
+    const deal = {
+      state_key: 'discovery_link_sent',
+      activity_log: [makeEvent('booking_nudge_sent', '2026-01-10T10:00:00Z')]
+    }
+    expect(getDealOwnership(deal)).toBe('them')
+  })
+})

package/src/business/acquisition/deal-ownership.ts

@@ -0,0 +1,120 @@
+// ---------------------------------------------------------------------------
+// Deal ownership axis — derived from activity_log (Pattern A, approved).
+//
+// Ownership reflects who owes the next move, not a stored column.
+// Closed deals always return null — ownership is meaningless once won/lost.
+// ---------------------------------------------------------------------------
+
+export type DealOwnership = 'us' | 'them' | null
+
+// Inbound events: lead acted, ball is in our court.
+const INBOUND_EVENT_TYPES = ['reply_received'] as const
+
+// Outbound events: we acted, ball is in their court.
+const OUTBOUND_EVENT_TYPES = [
+  'reply_sent_to_lead',
+  'booking_nudge_sent',
+  'reminder_sent',
+  'rebook_sent',
+  'followup_email_sent',
+  'reply_followup_sent',
+  'lead_deferred_next_step'
+] as const
+
+type InboundEventType = (typeof INBOUND_EVENT_TYPES)[number]
+type OutboundEventType = (typeof OUTBOUND_EVENT_TYPES)[number]
+
+const INBOUND_SET = new Set<string>(INBOUND_EVENT_TYPES)
+const OUTBOUND_SET = new Set<string>(OUTBOUND_EVENT_TYPES)
+
+interface DealOwnershipInput {
+  state_key: string | null
+  activity_log: unknown
+}
+
+/**
+ * Derives who owes the next move from the activity log.
+ *
+ * - `'us'`   — the lead replied last; we owe a response.
+ * - `'them'` — we sent something last; waiting on their reply.
+ * - `null`   — closed deal, or no inbound/outbound events present.
+ *
+ * Timestamp resolution matches the canonical pattern in crm-priority.ts:
+ * COALESCE across `timestamp ?? occurredAt ?? createdAt ?? updatedAt ?? sentAt`.
+ */
+export function getDealOwnership(deal: DealOwnershipInput): DealOwnership {
+  if (deal.state_key === 'closed_won' || deal.state_key === 'closed_lost') {
+    return null
+  }
+
+  if (!Array.isArray(deal.activity_log)) return null
+
+  let latestInboundMs: number | null = null
+  let latestOutboundMs: number | null = null
+
+  for (const entry of deal.activity_log) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue
+
+    const record = entry as Record<string, unknown>
+    const type = typeof record.type === 'string' ? record.type : null
+    if (!type) continue
+
+    const isInbound = INBOUND_SET.has(type)
+    const isOutbound = OUTBOUND_SET.has(type)
+    if (!isInbound && !isOutbound) continue
+
+    const occurredAt = resolveTimestamp(record)
+    if (occurredAt === null) continue
+
+    if (isInbound && (latestInboundMs === null || occurredAt > latestInboundMs)) {
+      latestInboundMs = occurredAt
+    }
+
+    if (isOutbound && (latestOutboundMs === null || occurredAt > latestOutboundMs)) {
+      latestOutboundMs = occurredAt
+    }
+  }
+
+  if (latestInboundMs === null && latestOutboundMs === null) return null
+
+  // Tie-break: outbound wins ("after we send, ball is in their court")
+  if (latestOutboundMs !== null && (latestInboundMs === null || latestOutboundMs >= latestInboundMs)) {
+    return 'them'
+  }
+
+  return 'us'
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * COALESCE timestamp fields in the same order as getParsedActivities in
+ * crm-priority.ts: timestamp → occurredAt → createdAt → updatedAt → sentAt.
+ * Returns milliseconds since epoch, or null if no valid date found.
+ */
+function resolveTimestamp(record: Record<string, unknown>): number | null {
+  return (
+    parseMs(record.timestamp) ??
+    parseMs(record.occurredAt) ??
+    parseMs(record.createdAt) ??
+    parseMs(record.updatedAt) ??
+    parseMs(record.sentAt) ??
+    null
+  )
+}
+
+function parseMs(value: unknown): number | null {
+  if (value instanceof Date) {
+    const ms = value.getTime()
+    return Number.isNaN(ms) ? null : ms
+  }
+  if (typeof value !== 'string') return null
+  const ms = new Date(value).getTime()
+  return Number.isNaN(ms) ? null : ms
+}
+
+// Re-export event type lists for consumers that want to introspect classification.
+export { INBOUND_EVENT_TYPES, OUTBOUND_EVENT_TYPES }
+export type { InboundEventType, OutboundEventType }

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

@@ -12,7 +12,9 @@ import { DEFAULT_CRM_ACTIONS, SendReplyActionPayloadSchema, deriveActions } from
  * Only stage_key and state_key affect availability logic; all other required
  * columns are filled with safe, inert defaults.
  */
-function makeDeal(overrides: Partial<Pick<AcqDealRow, 'stage_key' | 'state_key'>> = {}): AcqDealRow {
+function makeDeal(
+  overrides: Partial<AcqDealRow> & { ownership?: 'us' | 'them' | null; nextAction?: string | null } = {}
+): AcqDealRow & { ownership?: 'us' | 'them' | null; nextAction?: string | null } {
   return {
     id: 'deal-fixture-id',
     organization_id: 'org-fixture-id',
@@ -392,8 +394,10 @@ describe('deriveActions() — custom action set isolation', () => {
 // ---------------------------------------------------------------------------
 
 describe('deriveActions() — action metadata preservation', () => {
-  it('send_reply action includes payloadSchema in output', () => {
-    const actions = deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_replied' }))
+  it('send_reply action includes payloadSchema in output', () => {
+    const actions = deriveActions(
+      makeDeal({ stage_key: 'interested', state_key: 'discovery_replied', nextAction: 'send_reply' })
+    )
     const sendReply = actions.find((a) => a.key === 'send_reply')
     expect(sendReply).toBeDefined()
     expect(sendReply?.payloadSchema).toBeDefined()
@@ -459,40 +463,100 @@ describe('deriveActions() — multi-state discovery path coverage', () => {
     ])
   })
 
-  it('interested + discovery_replied: base actions plus send_reply and send_link', () => {
-    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_replied' }))).toEqual([
-      { key: 'move_to_proposal', label: 'Move to Proposal' },
-      { key: 'move_to_closed_lost', label: 'Close Lost' },
-      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
-      { key: 'send_reply', label: 'Send Reply', payloadSchema: SendReplyActionPayloadSchema },
-      { key: 'send_link', label: 'Send Booking Link' }
-    ])
-  })
-
-  it('interested + discovery_link_sent: base actions plus send_reply and send_nudge', () => {
-    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_link_sent' }))).toEqual([
-      { key: 'move_to_proposal', label: 'Move to Proposal' },
-      { key: 'move_to_closed_lost', label: 'Close Lost' },
-      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
-      { key: 'send_reply', label: 'Send Reply', payloadSchema: SendReplyActionPayloadSchema },
-      { key: 'send_nudge', label: 'Send Nudge' }
-    ])
-  })
-
-  it('interested + discovery_nudging: base actions plus send_reply, send_nudge, and mark_no_show', () => {
-    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_nudging' }))).toEqual([
-      { key: 'move_to_proposal', label: 'Move to Proposal' },
-      { key: 'move_to_closed_lost', label: 'Close Lost' },
-      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
-      { key: 'send_reply', label: 'Send Reply', payloadSchema: SendReplyActionPayloadSchema },
-      { key: 'send_nudge', label: 'Send Nudge' },
-      { key: 'mark_no_show', label: 'Mark No-Show' }
-    ])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Type-level smoke tests (compile-time only, no runtime assertions)
+  it('interested + discovery_replied: base actions plus send_link when no next move signal is available', () => {
+    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_replied' }))).toEqual([
+      { key: 'move_to_proposal', label: 'Move to Proposal' },
+      { key: 'move_to_closed_lost', label: 'Close Lost' },
+      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
+      { key: 'send_link', label: 'Send Booking Link' }
+    ])
+  })
+
+  it('interested + discovery_link_sent: base actions plus send_nudge', () => {
+    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_link_sent' }))).toEqual([
+      { key: 'move_to_proposal', label: 'Move to Proposal' },
+      { key: 'move_to_closed_lost', label: 'Close Lost' },
+      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
+      { key: 'send_nudge', label: 'Send Nudge' }
+    ])
+  })
+
+  it('interested + discovery_nudging: base actions plus send_nudge and mark_no_show', () => {
+    expect(deriveActions(makeDeal({ stage_key: 'interested', state_key: 'discovery_nudging' }))).toEqual([
+      { key: 'move_to_proposal', label: 'Move to Proposal' },
+      { key: 'move_to_closed_lost', label: 'Close Lost' },
+      { key: 'move_to_nurturing', label: 'Move to Nurturing' },
+      { key: 'send_nudge', label: 'Send Nudge' },
+      { key: 'mark_no_show', label: 'Mark No-Show' }
+    ])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// deriveActions() - ownership-gated reply action
+// ---------------------------------------------------------------------------
+
+describe('deriveActions() - ownership-gated reply action', () => {
+  it('lead asks us to respond: send_reply is available and ownership is our move', () => {
+    const actions = deriveActions(
+      makeDeal({
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        activity_log: [{ type: 'reply_received', timestamp: '2026-01-10T10:00:00Z' }]
+      })
+    )
+
+    expect(actions).toContainEqual({ key: 'send_reply', label: 'Send Reply', payloadSchema: SendReplyActionPayloadSchema })
+  })
+
+  it('lead deferred next step: send_reply is not available while it is their move', () => {
+    const actions = deriveActions(
+      makeDeal({
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        activity_log: [
+          { type: 'reply_received', timestamp: '2026-01-10T10:00:00Z' },
+          { type: 'lead_deferred_next_step', timestamp: '2026-01-10T10:05:00Z' }
+        ]
+      })
+    )
+
+    expect(actions.map((action) => action.key)).not.toContain('send_reply')
+    expect(actions).toContainEqual({ key: 'send_link', label: 'Send Booking Link' })
+  })
+
+  it('outbound after lead response: send_reply is not available while it is their move', () => {
+    const actions = deriveActions(
+      makeDeal({
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        activity_log: [
+          { type: 'reply_received', timestamp: '2026-01-10T10:00:00Z' },
+          { type: 'reply_sent_to_lead', timestamp: '2026-01-10T10:05:00Z' }
+        ]
+      })
+    )
+
+    expect(actions.map((action) => action.key)).not.toContain('send_reply')
+    expect(actions).toContainEqual({ key: 'send_link', label: 'Send Booking Link' })
+  })
+
+  it('uses projected nextAction before deriving from activity_log', () => {
+    const actions = deriveActions(
+      makeDeal({
+        stage_key: 'interested',
+        state_key: 'discovery_replied',
+        nextAction: null,
+        activity_log: [{ type: 'reply_received', timestamp: '2026-01-10T10:00:00Z' }]
+      })
+    )
+
+    expect(actions.map((action) => action.key)).not.toContain('send_reply')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Type-level smoke tests (compile-time only, no runtime assertions)
 // ---------------------------------------------------------------------------
 
 describe('type-level smoke', () => {