@open-mercato/core 0.10.1-develop.7672.1.c2e4c0b5df → 0.10.1-develop.7675.1.fb7858c0a2

package/src/helpers/integration/queue.ts

@@ -1,7 +1,9 @@
 import { spawn } from 'node:child_process'
 import { createRequire } from 'node:module'
 import path from 'node:path'
-import { drainQueueFromAppRoot } from './queue-runner'
+import { expect } from '@playwright/test'
+import { createQueue, getQueuePendingProbe } from '@open-mercato/queue'
+import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 
 type DrainQueueOptions = {
   appRoot?: string
@@ -15,6 +17,7 @@ function resolveAppRoot(input?: string): string {
 }
 
 async function drainQueueInCurrentProcess(queueName: string, options: Required<DrainQueueOptions>): Promise<number> {
+  const { drainQueueFromAppRoot } = await import('./queue-runner')
   return drainQueueFromAppRoot(queueName, options)
 }
 
@@ -69,6 +72,23 @@ function drainQueueInAppProcess(queueName: string, options: Required<DrainQueueO
   })
 }
 
+async function waitForManagedQueue(queueName: string, options: Required<DrainQueueOptions>): Promise<number> {
+  const baseDir = process.env.QUEUE_BASE_DIR?.trim() || path.resolve(options.appRoot, '.mercato/queue')
+  const queue = createQueue(queueName, 'local', { baseDir })
+  try {
+    const initial = await queue.getJobCounts()
+    await expect.poll(async () => {
+      const pending = await getQueuePendingProbe(queueName, 'local', { baseDir })
+      if (pending.error) throw new Error(`[internal] Cannot observe integration queue ${queueName}: ${pending.errorMessage}`)
+      return pending.ready + pending.active
+    }, { message: `Integration queue ${queueName} should finish processing` }).toBe(0)
+    const final = await queue.getJobCounts()
+    return final.completed + final.failed - initial.completed - initial.failed
+  } finally {
+    await queue.close()
+  }
+}
+
 export async function drainIntegrationQueue(queueName: string, options: DrainQueueOptions = {}): Promise<number> {
   const resolved = {
     appRoot: resolveAppRoot(options.appRoot),
@@ -77,5 +97,9 @@ export async function drainIntegrationQueue(queueName: string, options: DrainQue
   if (process.env.OM_TEST_APP_ROOT?.trim()) {
     return drainQueueInAppProcess(queueName, resolved)
   }
+  const managed = parseBooleanToken(process.env.AUTO_SPAWN_WORKERS)
+    ?? parseBooleanToken(process.env.OM_AUTO_SPAWN_WORKERS)
+    ?? true
+  if (managed) return waitForManagedQueue(queueName, resolved)
   return drainQueueInCurrentProcess(queueName, resolved)
 }

package/src/modules/customers/ai-tools/activities-tasks-pack.ts

@@ -10,12 +10,16 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import { z } from 'zod'
 import {
   createAiApiOperationRunner,
+  type AiApiOperationRequest,
   type AiToolExecutionContext,
 } from '@open-mercato/ai-assistant/modules/ai_assistant/lib/ai-api-operation-runner'
 import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { authorizeFeatures } from '@open-mercato/shared/security/featurePolicy'
 import { TERMINAL_INTERACTION_STATUS_LIST } from '../lib/interactionStatus'
+import { resolveCustomerInteractionFeatureFlags } from '../lib/interactionFeatureFlags'
+import { CUSTOMER_INTERACTION_ACTIVITY_ADAPTER_SOURCE } from '../lib/interactionCompatibility'
+import { listActivitiesForScope, loadActivityForScope, type ActivityRecord } from './activity-read-model'
 import {
-  CustomerActivity,
   CustomerComment,
   CustomerDeal,
   CustomerDealCompanyLink,
@@ -149,35 +153,51 @@ async function loadCommentForScope(
   return row
 }
 
-async function loadActivityForScope(
-  em: EntityManager,
-  ctx: CustomersToolContext,
-  tenantId: string,
-  activityId: string,
-): Promise<CustomerActivity | null> {
-  const where: Record<string, unknown> = { id: activityId, tenantId }
-  if (ctx.organizationId) where.organizationId = ctx.organizationId
-  const row = await findOneWithDecryption<CustomerActivity>(
-    em,
-    CustomerActivity,
-    where as any,
-    undefined,
-    buildScope(ctx, tenantId),
-  )
-  if (!row || row.tenantId !== tenantId) return null
-  if (ctx.organizationId && row.organizationId !== ctx.organizationId) return null
-  return row
+async function runActivityOperation(ctx: CustomersToolContext, request: AiApiOperationRequest) {
+  const { tenantId } = assertTenantScope(ctx)
+  const flags = await resolveCustomerInteractionFeatureFlags(ctx.container, tenantId)
+  const executionContext = ctx as AiToolExecutionContext
+  if (flags.legacyAdapters) {
+    return createAiApiOperationRunner(executionContext).run(request)
+  }
+  const requiredFeatures = ['customers.interactions.manage']
+  if (!authorizeFeatures(requiredFeatures, {
+    grantedFeatures: ctx.userFeatures,
+    unrestricted: ctx.isSuperAdmin,
+  })) {
+    throw new Error('[internal] Canonical interaction management permission is required')
+  }
+  const { activityType, subject, ...body } = request.body ?? {}
+  const runner = createAiApiOperationRunner({
+    ...executionContext,
+    tool: { ...executionContext.tool, requiredFeatures },
+  })
+  return runner.run({
+    ...request,
+    path: '/customers/interactions',
+    body: {
+      ...body,
+      ...(activityType !== undefined ? { interactionType: activityType } : {}),
+      ...(subject !== undefined ? { title: subject } : {}),
+      ...(request.method === 'POST' ? {
+        source: CUSTOMER_INTERACTION_ACTIVITY_ADAPTER_SOURCE,
+        status: body.occurredAt ? 'done' : 'planned',
+      } : {}),
+      ...(request.method === 'PUT' && body.occurredAt ? { status: 'done' } : {}),
+    },
+  })
 }
 
-function commentEntityIdOf(row: CustomerComment): string | null {
-  const ent = (row as any).entity
-  if (!ent) return null
-  if (typeof ent === 'string') return ent
-  if (typeof ent === 'object' && typeof ent.id === 'string') return ent.id
-  return null
+function activitySnapshot(activity: ActivityRecord | null) {
+  return activity ? {
+    activityType: activity.activityType,
+    subject: activity.subject,
+    body: activity.body,
+    occurredAt: activity.occurredAt?.toISOString() ?? null,
+  } : null
 }
 
-function activityEntityIdOf(row: CustomerActivity): string | null {
+function commentEntityIdOf(row: CustomerComment): string | null {
   const ent = (row as any).entity
   if (!ent) return null
   if (typeof ent === 'string') return ent
@@ -210,33 +230,17 @@ const listActivitiesTool: CustomersAiToolDefinition = {
     const em = resolveEm(ctx)
     const limit = input.limit ?? 50
     const offset = input.offset ?? 0
-    const where: Record<string, unknown> = { tenantId }
-    if (ctx.organizationId) where.organizationId = ctx.organizationId
-    const entityId = input.personId ?? input.companyId ?? null
-    if (entityId) where.entity = entityId
-    if (input.dealId) where.deal = input.dealId
-    if (input.activityType) where.activityType = input.activityType
-    const [rows, total] = await Promise.all([
-      findWithDecryption<CustomerActivity>(
-        em,
-        CustomerActivity,
-        where as any,
-        { limit, offset, orderBy: { occurredAt: 'desc', createdAt: 'desc' } as any } as any,
-        buildScope(ctx, tenantId),
-      ),
-      em.count(CustomerActivity, where as any),
-    ])
-    const filtered = rows.filter((row) => row.tenantId === tenantId)
+    const { items: rows, total } = await listActivitiesForScope(em, ctx, tenantId, { ...input, limit, offset })
     return {
-      items: filtered.map((row) => ({
+      items: rows.map((row) => ({
         id: row.id,
         activityType: row.activityType,
         subject: row.subject ?? null,
         body: row.body ?? null,
         occurredAt: row.occurredAt ? new Date(row.occurredAt).toISOString() : null,
         authorUserId: row.authorUserId ?? null,
-        entityId: activityEntityIdOf(row),
-        dealId: (row as any).deal && typeof (row as any).deal === 'object' ? (row as any).deal.id : (row as any).deal ?? null,
+        entityId: row.entityId,
+        dealId: row.dealId,
         organizationId: row.organizationId ?? null,
         tenantId: row.tenantId ?? null,
         createdAt: row.createdAt ? new Date(row.createdAt).toISOString() : null,
@@ -645,16 +649,14 @@ const manageDealActivityTool: CustomersAiToolDefinition = {
     if (!existing) return null
     return {
       recordId: existing.id,
-      entityType: 'customers.customer_activity',
+      entityType: existing.entityType,
       recordVersion: recordVersionFromUpdatedAt(existing.updatedAt),
       before: {
         activityType: existing.activityType,
         subject: existing.subject ?? null,
         body: existing.body ?? null,
         occurredAt: existing.occurredAt ? new Date(existing.occurredAt).toISOString() : null,
-        dealId: (existing as any).deal && typeof (existing as any).deal === 'object'
-          ? (existing as any).deal.id
-          : (existing as any).deal ?? null,
+        dealId: existing.dealId,
       },
     }
   },
@@ -662,7 +664,6 @@ const manageDealActivityTool: CustomersAiToolDefinition = {
     const { tenantId } = assertTenantScope(ctx)
     const input: ManageDealActivityInput = manageDealActivityInput.parse(rawInput)
     const em = resolveEm(ctx)
-    const runner = createAiApiOperationRunner(ctx as unknown as AiToolExecutionContext)
 
     if (input.operation === 'create') {
       const deal = await loadDealForScope(em, ctx, tenantId, input.dealId!)
@@ -686,23 +687,19 @@ const manageDealActivityTool: CustomersAiToolDefinition = {
       if (input.subject) body.subject = input.subject
       if (input.body) body.body = input.body
       if (input.occurredAt) body.occurredAt = input.occurredAt
-      const response = await runner.run({ method: 'POST', path: '/customers/activities', body })
+      const response = await runActivityOperation(ctx, { method: 'POST', path: '/customers/activities', body })
       if (!response.success) {
         throw new Error(response.error ?? 'Failed to create activity')
       }
       const result = (response.data ?? {}) as { id?: string | null }
+      const created = result.id ? await loadActivityForScope(em, ctx, tenantId, result.id) : null
       return {
         operation: 'create' as const,
         activityId: result.id ?? null,
         dealId: deal.id,
         commandName: 'customers.activities.create',
         before: null,
-        after: {
-          activityType: input.activityType ?? null,
-          subject: input.subject ?? null,
-          body: input.body ?? null,
-          occurredAt: input.occurredAt ?? null,
-        },
+        after: activitySnapshot(created),
       }
     }
 
@@ -716,7 +713,7 @@ const manageDealActivityTool: CustomersAiToolDefinition = {
       if (input.subject !== undefined) body.subject = input.subject
       if (input.body !== undefined) body.body = input.body
       if (input.occurredAt !== undefined) body.occurredAt = input.occurredAt
-      const response = await runner.run({ method: 'PUT', path: '/customers/activities', body })
+      const response = await runActivityOperation(ctx, { method: 'PUT', path: '/customers/activities', body })
       if (!response.success) {
         throw new Error(response.error ?? `Failed to update activity "${existing.id}"`)
       }
@@ -746,7 +743,7 @@ const manageDealActivityTool: CustomersAiToolDefinition = {
     const existing = await loadActivityForScope(em, ctx, tenantId, input.activityId!)
     if (!existing) throw new Error(`Activity "${input.activityId}" is not accessible to the caller.`)
     const body: Record<string, unknown> = { id: existing.id }
-    const response = await runner.run({ method: 'DELETE', path: '/customers/activities', body })
+    const response = await runActivityOperation(ctx, { method: 'DELETE', path: '/customers/activities', body })
     if (!response.success) {
       throw new Error(response.error ?? `Failed to delete activity "${existing.id}"`)
     }
@@ -1131,17 +1128,15 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
     if (!existing) return null
     return {
       recordId: existing.id,
-      entityType: 'customers.customer_activity',
+      entityType: existing.entityType,
       recordVersion: recordVersionFromUpdatedAt(existing.updatedAt),
       before: {
         activityType: existing.activityType,
         subject: existing.subject ?? null,
         body: existing.body ?? null,
         occurredAt: existing.occurredAt ? new Date(existing.occurredAt).toISOString() : null,
-        entityId: activityEntityIdOf(existing),
-        dealId: (existing as any).deal && typeof (existing as any).deal === 'object'
-          ? (existing as any).deal.id
-          : (existing as any).deal ?? null,
+        entityId: existing.entityId,
+        dealId: existing.dealId,
       },
     }
   },
@@ -1149,7 +1144,6 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
     const { tenantId } = assertTenantScope(ctx)
     const input: ManageRecordActivityInput = manageRecordActivityInput.parse(rawInput)
     const em = resolveEm(ctx)
-    const runner = createAiApiOperationRunner(ctx as unknown as AiToolExecutionContext)
 
     if (input.operation === 'create') {
       const entityId = input.personId ?? input.companyId!
@@ -1174,11 +1168,12 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
       if (input.subject) body.subject = input.subject
       if (input.body) body.body = input.body
       if (input.occurredAt) body.occurredAt = input.occurredAt
-      const response = await runner.run({ method: 'POST', path: '/customers/activities', body })
+      const response = await runActivityOperation(ctx, { method: 'POST', path: '/customers/activities', body })
       if (!response.success) {
         throw new Error(response.error ?? 'Failed to create activity')
       }
       const result = (response.data ?? {}) as { id?: string | null }
+      const created = result.id ? await loadActivityForScope(em, ctx, tenantId, result.id) : null
       return {
         operation: 'create' as const,
         activityId: result.id ?? null,
@@ -1186,12 +1181,7 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
         dealId,
         commandName: 'customers.activities.create',
         before: null,
-        after: {
-          activityType: input.activityType ?? null,
-          subject: input.subject ?? null,
-          body: input.body ?? null,
-          occurredAt: input.occurredAt ?? null,
-        },
+        after: activitySnapshot(created),
       }
     }
 
@@ -1205,7 +1195,7 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
       if (input.subject !== undefined) body.subject = input.subject
       if (input.body !== undefined) body.body = input.body
       if (input.occurredAt !== undefined) body.occurredAt = input.occurredAt
-      const response = await runner.run({ method: 'PUT', path: '/customers/activities', body })
+      const response = await runActivityOperation(ctx, { method: 'PUT', path: '/customers/activities', body })
       if (!response.success) {
         throw new Error(response.error ?? `Failed to update activity "${existing.id}"`)
       }
@@ -1235,7 +1225,7 @@ const manageRecordActivityTool: CustomersAiToolDefinition = {
     const existing = await loadActivityForScope(em, ctx, tenantId, input.activityId!)
     if (!existing) throw new Error(`Activity "${input.activityId}" is not accessible to the caller.`)
     const body: Record<string, unknown> = { id: existing.id }
-    const response = await runner.run({ method: 'DELETE', path: '/customers/activities', body })
+    const response = await runActivityOperation(ctx, { method: 'DELETE', path: '/customers/activities', body })
     if (!response.success) {
       throw new Error(response.error ?? `Failed to delete activity "${existing.id}"`)
     }

package/src/modules/customers/ai-tools/activity-read-model.ts

@@ -0,0 +1,228 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CustomerActivity, CustomerInteraction } from '../data/entities'
+import { listGrantsForViewer, listSharedChannelIds } from '../lib/conversationShares'
+import { CUSTOMER_INTERACTION_ACTIVITY_ADAPTER_SOURCE } from '../lib/interactionCompatibility'
+import { resolveCustomerInteractionFeatureFlags } from '../lib/interactionFeatureFlags'
+import { buildEmailVisibilityMikroFilter, isEmailHiddenFrom } from '../lib/visibilityFilter'
+import type { CustomersToolContext } from './types'
+
+export type ActivityRecord = {
+  id: string
+  activityType: string
+  subject: string | null
+  body: string | null
+  occurredAt: Date | null
+  authorUserId: string | null
+  entityId: string | null
+  dealId: string | null
+  organizationId: string
+  tenantId: string
+  createdAt: Date
+  updatedAt: Date | null
+  entityType: string
+}
+
+type ActivityListInput = {
+  personId?: string
+  companyId?: string
+  dealId?: string
+  activityType?: string
+  limit: number
+  offset: number
+}
+
+const activityOrder = { occurredAt: 'DESC NULLS LAST', createdAt: 'DESC', id: 'DESC' } as const
+
+function buildScope(ctx: CustomersToolContext, tenantId: string) {
+  return { tenantId, ...(ctx.organizationId ? { organizationId: ctx.organizationId } : {}) }
+}
+
+function isInScope(row: { tenantId: string; organizationId: string }, ctx: CustomersToolContext, tenantId: string) {
+  return row.tenantId === tenantId && (!ctx.organizationId || row.organizationId === ctx.organizationId)
+}
+
+function relationId(value: unknown): string | null {
+  if (typeof value === 'string') return value
+  if (value && typeof value === 'object' && 'id' in value && typeof value.id === 'string') return value.id
+  return null
+}
+
+function copyDate(value: Date | null | undefined): Date | null {
+  return value ? new Date(value) : null
+}
+
+function canonicalActivity(row: CustomerInteraction): ActivityRecord {
+  return {
+    id: row.id,
+    activityType: row.interactionType,
+    subject: row.title ?? null,
+    body: row.body ?? null,
+    occurredAt: copyDate(row.occurredAt),
+    authorUserId: row.authorUserId ?? null,
+    entityId: relationId(row.entity),
+    dealId: row.dealId ?? null,
+    organizationId: row.organizationId,
+    tenantId: row.tenantId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: copyDate(row.updatedAt),
+    entityType: 'customers.customer_interaction',
+  }
+}
+
+function legacyActivity(row: CustomerActivity): ActivityRecord {
+  return {
+    id: row.id,
+    activityType: row.activityType,
+    subject: row.subject ?? null,
+    body: row.body ?? null,
+    occurredAt: copyDate(row.occurredAt),
+    authorUserId: row.authorUserId ?? null,
+    entityId: relationId(row.entity),
+    dealId: relationId(row.deal),
+    organizationId: row.organizationId,
+    tenantId: row.tenantId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: copyDate(row.updatedAt),
+    entityType: 'customers.customer_activity',
+  }
+}
+
+async function resolveVisibility(em: EntityManager, ctx: CustomersToolContext, tenantId: string) {
+  const currentUserId = ctx.userId?.startsWith('api_key:') ? null : ctx.userId
+  const scope = { tenantId, organizationId: ctx.organizationId }
+  const [sharedConversations, sharedChannelIds] = await Promise.all([
+    listGrantsForViewer(em, scope, currentUserId),
+    listSharedChannelIds(em, scope, currentUserId),
+  ])
+  return { currentUserId, userFeatures: ctx.userFeatures, sharedConversations, sharedChannelIds }
+}
+
+export async function loadActivityForScope(
+  em: EntityManager,
+  ctx: CustomersToolContext,
+  tenantId: string,
+  activityId: string,
+): Promise<ActivityRecord | null> {
+  const scope = buildScope(ctx, tenantId)
+  const canonical = await findOneWithDecryption(
+    em,
+    CustomerInteraction,
+    { ...scope, id: activityId },
+    { refresh: true },
+    scope,
+  )
+  if (canonical) {
+    if (!isInScope(canonical, ctx, tenantId) || canonical.deletedAt || canonical.interactionType === 'task') return null
+    const visibility = await resolveVisibility(em, ctx, tenantId)
+    if (isEmailHiddenFrom({
+      ...visibility,
+      interactionType: canonical.interactionType,
+      visibility: canonical.visibility,
+      authorUserId: canonical.authorUserId,
+      personEntityId: relationId(canonical.entity),
+      channelId: canonical.channelId,
+    })) return null
+    return canonicalActivity(canonical)
+  }
+  const flags = await resolveCustomerInteractionFeatureFlags(ctx.container, tenantId)
+  if (flags.unified || !flags.legacyAdapters) return null
+  const legacy = await findOneWithDecryption(
+    em,
+    CustomerActivity,
+    { ...scope, id: activityId },
+    { refresh: true },
+    scope,
+  )
+  return legacy && isInScope(legacy, ctx, tenantId) ? legacyActivity(legacy) : null
+}
+
+function compareActivities(left: ActivityRecord, right: ActivityRecord): number {
+  const leftOccurredAt = left.occurredAt?.getTime() ?? Number.NEGATIVE_INFINITY
+  const rightOccurredAt = right.occurredAt?.getTime() ?? Number.NEGATIVE_INFINITY
+  if (leftOccurredAt !== rightOccurredAt) return rightOccurredAt - leftOccurredAt
+  const createdAtDifference = right.createdAt.getTime() - left.createdAt.getTime()
+  return createdAtDifference || right.id.localeCompare(left.id)
+}
+
+export async function listActivitiesForScope(
+  em: EntityManager,
+  ctx: CustomersToolContext,
+  tenantId: string,
+  input: ActivityListInput,
+): Promise<{ items: ActivityRecord[]; total: number }> {
+  const scope = buildScope(ctx, tenantId)
+  const [flags, visibility] = await Promise.all([
+    resolveCustomerInteractionFeatureFlags(ctx.container, tenantId),
+    resolveVisibility(em, ctx, tenantId),
+  ])
+  const includeLegacy = !flags.unified && flags.legacyAdapters
+  const entityId = input.personId ?? input.companyId
+  const canonicalWhere: FilterQuery<CustomerInteraction> = {
+    ...scope,
+    ...buildEmailVisibilityMikroFilter(visibility),
+    deletedAt: null,
+    interactionType: input.activityType ?? { $ne: 'task' },
+    ...(entityId ? { entity: entityId } : {}),
+    ...(input.dealId ? { dealId: input.dealId } : {}),
+    ...(includeLegacy ? { source: CUSTOMER_INTERACTION_ACTIVITY_ADAPTER_SOURCE } : {}),
+  }
+  const loadCanonical = async (offset: number, limit: number): Promise<ActivityRecord[]> => {
+    if (input.activityType === 'task') return []
+    const rows = await findWithDecryption(
+      em, CustomerInteraction, canonicalWhere, { limit, offset, orderBy: activityOrder, refresh: true }, scope,
+    )
+    return rows.filter((row) => isInScope(row, ctx, tenantId)).map(canonicalActivity)
+  }
+  const countCanonical = () => input.activityType === 'task' ? Promise.resolve(0) : em.count(CustomerInteraction, canonicalWhere)
+  if (!includeLegacy) {
+    const [items, total] = await Promise.all([
+      loadCanonical(input.offset, input.limit),
+      countCanonical(),
+    ])
+    return { items, total }
+  }
+  const canonicalIds = em.createQueryBuilder(CustomerInteraction).select('id').where(scope)
+  const legacyWhere: FilterQuery<CustomerActivity> = {
+    ...scope,
+    id: { $nin: canonicalIds },
+    ...(entityId ? { entity: entityId } : {}),
+    ...(input.dealId ? { deal: input.dealId } : {}),
+    ...(input.activityType ? { activityType: input.activityType } : {}),
+  }
+  const loadLegacy = async (offset: number, limit: number): Promise<ActivityRecord[]> => {
+    const rows = await findWithDecryption(
+      em, CustomerActivity, legacyWhere, { limit, offset, orderBy: activityOrder, refresh: true }, scope,
+    )
+    return rows.filter((row) => isInScope(row, ctx, tenantId)).map(legacyActivity)
+  }
+  const [canonicalTotal, legacyTotal] = await Promise.all([
+    countCanonical(),
+    em.count(CustomerActivity, legacyWhere),
+  ])
+  const total = canonicalTotal + legacyTotal
+  if (input.offset >= total) return { items: [], total }
+  let lowerCanonicalOffset = Math.max(0, input.offset - legacyTotal)
+  let upperCanonicalOffset = Math.min(input.offset, canonicalTotal)
+  while (lowerCanonicalOffset < upperCanonicalOffset) {
+    const canonicalOffset = Math.floor((lowerCanonicalOffset + upperCanonicalOffset) / 2)
+    const legacyOffset = input.offset - canonicalOffset
+    const [canonicalNext, legacyPrevious] = await Promise.all([
+      loadCanonical(canonicalOffset, 1),
+      loadLegacy(legacyOffset - 1, 1),
+    ])
+    if (canonicalNext[0] && legacyPrevious[0] && compareActivities(canonicalNext[0], legacyPrevious[0]) < 0) {
+      lowerCanonicalOffset = canonicalOffset + 1
+    } else {
+      upperCanonicalOffset = canonicalOffset
+    }
+  }
+  const [canonicalItems, legacyItems] = await Promise.all([
+    loadCanonical(lowerCanonicalOffset, input.limit),
+    loadLegacy(input.offset - lowerCanonicalOffset, input.limit),
+  ])
+  return {
+    items: [...canonicalItems, ...legacyItems].sort(compareActivities).slice(0, input.limit),
+    total,
+  }
+}

package/src/modules/customers/commands/companies.ts

@@ -138,8 +138,11 @@ type CompanyAddressSnapshot = {
   id: string
   name: string | null
   purpose: string | null
+  companyName?: string | null
   addressLine1: string
   addressLine2: string | null
+  buildingNumber?: string | null
+  flatNumber?: string | null
   city: string | null
   region: string | null
   postalCode: string | null
@@ -359,8 +362,11 @@ async function loadCompanySnapshot(
       id: address.id,
       name: address.name ?? null,
       purpose: address.purpose ?? null,
+      companyName: address.companyName ?? null,
       addressLine1: address.addressLine1,
       addressLine2: address.addressLine2 ?? null,
+      buildingNumber: address.buildingNumber ?? null,
+      flatNumber: address.flatNumber ?? null,
       city: address.city ?? null,
       region: address.region ?? null,
       postalCode: address.postalCode ?? null,
@@ -1387,8 +1393,11 @@ const deleteCompanyCommand: CommandHandler<
               entity,
               name: address.name,
               purpose: address.purpose,
+              companyName: address.companyName ?? null,
               addressLine1: address.addressLine1,
               addressLine2: address.addressLine2,
+              buildingNumber: address.buildingNumber ?? null,
+              flatNumber: address.flatNumber ?? null,
               city: address.city,
               region: address.region,
               postalCode: address.postalCode,

package/src/modules/customers/commands/people.ts

@@ -84,8 +84,11 @@ type PersonAddressSnapshot = {
   id: string
   name: string | null
   purpose: string | null
+  companyName?: string | null
   addressLine1: string
   addressLine2: string | null
+  buildingNumber?: string | null
+  flatNumber?: string | null
   city: string | null
   region: string | null
   postalCode: string | null
@@ -344,8 +347,11 @@ function serializePersonSnapshot(
       id: address.id,
       name: address.name ?? null,
       purpose: address.purpose ?? null,
+      companyName: address.companyName ?? null,
       addressLine1: address.addressLine1,
       addressLine2: address.addressLine2 ?? null,
+      buildingNumber: address.buildingNumber ?? null,
+      flatNumber: address.flatNumber ?? null,
       city: address.city ?? null,
       region: address.region ?? null,
       postalCode: address.postalCode ?? null,
@@ -1684,8 +1690,11 @@ const deletePersonCommand: CommandHandler<
           entity,
           name: address.name,
           purpose: address.purpose,
+          companyName: address.companyName ?? null,
           addressLine1: address.addressLine1,
           addressLine2: address.addressLine2,
+          buildingNumber: address.buildingNumber ?? null,
+          flatNumber: address.flatNumber ?? null,
           city: address.city,
           region: address.region,
           postalCode: address.postalCode,