@open-mercato/core 0.6.8-develop.7013.1.48f7adca80 → 0.6.8-develop.7015.1.af90a2ddc7

package/src/modules/customers/api/companies/[id]/people/route.ts

@@ -7,17 +7,10 @@ import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
-import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { isOrganizationReadAccessAllowed } from '@open-mercato/core/modules/directory/utils/organizationScopeGuard'
-import {
-  CustomerEntity,
-  CustomerPersonCompanyLink,
-  CustomerPersonProfile,
-} from '../../../../data/entities'
-import {
-  filterActivePersonCompanyLinks,
-  withActiveCustomerPersonCompanyLinkFilter,
-} from '../../../../lib/personCompanyLinkTable'
+import { CustomerEntity } from '../../../../data/entities'
+import { loadCompanyPeopleUnion } from '../../../../lib/personCompanies'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('customers')
@@ -124,68 +117,23 @@ export async function GET(req: Request, ctx: { params?: { id?: string } }) {
     }
 
     const entityScope = { tenantId: auth.tenantId, organizationId: company.organizationId }
-    const linkWhere = await withActiveCustomerPersonCompanyLinkFilter(
-      em,
-      {
-        company: company.id,
-        tenantId: company.tenantId,
-        organizationId: company.organizationId,
-      },
-      'customers.companies.people.GET',
-    )
-    const links = filterActivePersonCompanyLinks(
-      await findWithDecryption(
-        em,
-        CustomerPersonCompanyLink,
-        linkWhere,
-        { populate: ['person'] },
-        entityScope,
-      ),
-    )
-
-    const personIds = links
-      .map((link) => link.person?.id)
-      .filter((personId): personId is string => typeof personId === 'string' && personId.length > 0)
-
-    const profiles = personIds.length > 0
-      ? await findWithDecryption(
-          em,
-          CustomerPersonProfile,
-          {
-            entity: { $in: personIds },
-            tenantId: company.tenantId,
-            organizationId: company.organizationId,
-          },
-          {},
-          entityScope,
-        )
-      : []
-    const profileByPersonId = new Map(
-      profiles.map((profile) => [(profile.entity as { id: string }).id, profile]),
-    )
-
-    const items = links
-      .map((link) => {
-        const person = link.person
-        if (!person?.id) return null
-        const profile = profileByPersonId.get(person.id) ?? null
-        return {
-          id: person.id,
-          displayName: person.displayName ?? person.primaryEmail ?? person.id,
-          primaryEmail: person.primaryEmail ?? null,
-          primaryPhone: person.primaryPhone ?? null,
-          status: person.status ?? null,
-          lifecycleStage: person.lifecycleStage ?? null,
-          jobTitle: profile?.jobTitle ?? null,
-          department: profile?.department ?? null,
-          createdAt: person.createdAt.toISOString(),
-          organizationId: person.organizationId,
-          temperature: person.temperature ?? null,
-          source: person.source ?? null,
-          linkedAt: link.createdAt ? link.createdAt.toISOString() : null,
-        } satisfies CompanyPersonItem
-      })
-      .filter((item): item is CompanyPersonItem => item !== null)
+    const union = await loadCompanyPeopleUnion(em, company, entityScope)
+
+    const items = union.map(({ entity: person, profile, linkedAt }) => ({
+      id: person.id,
+      displayName: person.displayName ?? person.primaryEmail ?? person.id,
+      primaryEmail: person.primaryEmail ?? null,
+      primaryPhone: person.primaryPhone ?? null,
+      status: person.status ?? null,
+      lifecycleStage: person.lifecycleStage ?? null,
+      jobTitle: profile?.jobTitle ?? null,
+      department: profile?.department ?? null,
+      createdAt: person.createdAt.toISOString(),
+      organizationId: person.organizationId,
+      temperature: person.temperature ?? null,
+      source: person.source ?? null,
+      linkedAt,
+    } satisfies CompanyPersonItem))
 
     const filtered = query.search?.trim().length ? items.filter((item) => matchesSearch(item, query.search ?? '')) : items
     const sorted = sortItems(filtered, query.sort)

package/src/modules/customers/api/companies/[id]/route.ts

@@ -17,8 +17,6 @@ import {
   CustomerDealCompanyLink,
   CustomerDeal,
   CustomerTodoLink,
-  CustomerPersonCompanyLink,
-  CustomerPersonProfile,
   CustomerInteraction,
 } from '../../../data/entities'
 import { User } from '@open-mercato/core/modules/auth/data/entities'
@@ -47,9 +45,10 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { parseBooleanFromUnknown } from '@open-mercato/shared/lib/boolean'
 import {
-  filterActivePersonCompanyLinks,
-  withActiveCustomerPersonCompanyLinkFilter,
-} from '../../../lib/personCompanyLinkTable'
+  countCompanyPeopleUnion,
+  loadCompanyPeopleUnion,
+  type CompanyPersonUnionEntry,
+} from '../../../lib/personCompanies'
 import { normalizeCustomerDetailCustomFields } from '../../detailCustomFields'
 import { isOrganizationReadAccessAllowed } from '@open-mercato/core/modules/directory/utils/organizationScopeGuard'
 import { runWithCacheTenant } from '@open-mercato/cache'
@@ -801,79 +800,13 @@ export async function GET(_req: Request, ctx: { params?: { id?: string } }) {
             deal.organizationId === company.organizationId,
         )
 
-  let relatedPeople: Array<{
-    entity: CustomerEntity
-    profile: CustomerPersonProfile | null
-    linkedAt: string | null
-  }> = []
+  const peopleUnionScope = {
+    tenantId: company.tenantId ?? auth.tenantId ?? null,
+    organizationId: company.organizationId ?? scope?.selectedId ?? auth.orgId ?? null,
+  }
+  let relatedPeople: CompanyPersonUnionEntry[] = []
   if (includePeople) {
-    const peopleDecryptionScope = {
-      tenantId: company.tenantId ?? auth.tenantId ?? null,
-      organizationId: company.organizationId ?? scope?.selectedId ?? auth.orgId ?? null,
-    }
-    const relatedPeopleById = new Map<
-      string,
-      { entity: CustomerEntity; profile: CustomerPersonProfile | null; linkedAt: string | null }
-    >()
-    const companyLinkWhere = await withActiveCustomerPersonCompanyLinkFilter(
-      em,
-      {
-        company: company.id,
-        organizationId: company.organizationId,
-        tenantId: company.tenantId,
-      },
-      'customers.companies.GET',
-    )
-    const companyLinks = filterActivePersonCompanyLinks(
-      await findWithDecryption(
-        em,
-        CustomerPersonCompanyLink,
-        companyLinkWhere,
-        {
-          populate: ['person', 'person.personProfile'],
-          orderBy: { isPrimary: 'desc', createdAt: 'asc' },
-        },
-        peopleDecryptionScope,
-      ),
-    )
-    companyLinks.forEach((link) => {
-      const entity = typeof link.person === 'string' ? null : link.person
-      if (!entity || entity.kind !== 'person' || entity.deletedAt) return
-      const personProfile =
-        entity.personProfile && typeof entity.personProfile !== 'string'
-          ? entity.personProfile
-          : null
-      relatedPeopleById.set(entity.id, {
-        entity,
-        profile: personProfile,
-        linkedAt: link.createdAt instanceof Date ? link.createdAt.toISOString() : null,
-      })
-    })
-
-    const profiles = await findWithDecryption(
-      em,
-      CustomerPersonProfile,
-      {
-        company: company.id,
-        tenantId: company.tenantId,
-        organizationId: company.organizationId,
-        entity: { deletedAt: null },
-      },
-      { populate: ['entity'] },
-      peopleDecryptionScope,
-    )
-    profiles.forEach((entry) => {
-      const entity = entry.entity as CustomerEntity | null
-      if (!entity || entity.kind !== 'person' || entity.deletedAt) return
-      if (!relatedPeopleById.has(entity.id)) {
-        relatedPeopleById.set(entity.id, {
-          entity,
-          profile: entry ?? null,
-          linkedAt: entry.createdAt instanceof Date ? entry.createdAt.toISOString() : null,
-        })
-      }
-    })
-    relatedPeople = Array.from(relatedPeopleById.values())
+    relatedPeople = await loadCompanyPeopleUnion(em, company, peopleUnionScope)
   }
 
   // Entity custom fields, profile custom fields, and the routing lookup do not
@@ -919,26 +852,7 @@ export async function GET(_req: Request, ctx: { params?: { id?: string } }) {
   // instead of a waterfall (issue #3203).
   const peopleCountQuery = includePeople
     ? Promise.resolve(relatedPeople.length)
-    : (async () => {
-        const peopleLinkWhere = await withActiveCustomerPersonCompanyLinkFilter(
-          em,
-          {
-            company: company.id,
-            organizationId: company.organizationId,
-            tenantId: company.tenantId,
-          },
-          'customers.companies.GET',
-        )
-        return filterActivePersonCompanyLinks(
-          await findWithDecryption(
-            em,
-            CustomerPersonCompanyLink,
-            peopleLinkWhere,
-            {},
-            { tenantId: company.tenantId, organizationId: company.organizationId },
-          ),
-        ).length
-      })()
+    : countCompanyPeopleUnion(em, company)
   const [
     activityCount,
     interactionCount,

package/src/modules/customers/api/people/[id]/companies/[linkId]/route.ts

@@ -234,7 +234,7 @@ export async function DELETE(req: Request, ctx: { params?: { id?: string; linkId
   const { translate } = await resolveTranslations()
   try {
     const { id, linkId } = paramsSchema.parse({ id: ctx.params?.id, linkId: ctx.params?.linkId })
-    const { container, auth, selectedOrganizationId, person } = await loadPersonContext(req, id)
+    const { container, auth, selectedOrganizationId, person, profile } = await loadPersonContext(req, id)
     if (!selectedOrganizationId) {
       throw new CrudHttpError(400, { error: translate('customers.errors.organization_required', 'Organization context is required') })
     }
@@ -262,18 +262,26 @@ export async function DELETE(req: Request, ctx: { params?: { id?: string; linkId
       auth.tenantId,
       selectedOrganizationId,
     )
-    if (!resolvedLinkId) {
+    // No `CustomerPersonCompanyLink` row resolves for the profile-only association case
+    // (`CustomerPersonProfile.company` set without a link row, e.g. from a CRM migration).
+    // The delete command accepts that shape too, so it is dispatched instead of 404ing and
+    // the detach keeps its audit entry, undo token and cache invalidation (#5114).
+    const isProfileOnlyMatch =
+      profile.company && typeof profile.company !== 'string' && profile.company.id === linkId
+    if (!resolvedLinkId && !isProfileOnlyMatch) {
       throw notFound(translate('customers.errors.person_company_link_not_found', 'Person-company link not found'))
     }
 
     const commandInput = personCompanyLinkDeleteSchema.parse({
-      linkId: resolvedLinkId,
+      ...(resolvedLinkId
+        ? { linkId: resolvedLinkId }
+        : { personEntityId: person.id, companyEntityId: linkId }),
       tenantId: auth.tenantId,
       organizationId: selectedOrganizationId,
     } satisfies PersonCompanyLinkDeleteInput)
 
     const commandBus = container.resolve('commandBus') as CommandBus
-    const { result, logEntry } = await commandBus.execute<PersonCompanyLinkDeleteInput, { linkId: string }>(
+    const { result, logEntry } = await commandBus.execute<PersonCompanyLinkDeleteInput, { linkId: string | null }>(
       'customers.personCompanyLinks.delete',
       {
         input: commandInput,

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

@@ -1,5 +1,5 @@
 import { registerCommand } from '@open-mercato/shared/lib/commands'
-import type { CommandHandler } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
 import type { CrudEventsConfig } from '@open-mercato/shared/lib/crud/types'
 import { emitCrudSideEffects, emitCrudUndoSideEffects } from '@open-mercato/shared/lib/commands/helpers'
 import { CrudHttpError, notFound } from '@open-mercato/shared/lib/crud/errors'
@@ -24,14 +24,27 @@ import {
   findDeletedPersonCompanyLink,
   loadPersonCompanyLinks,
   promoteFallbackPrimaryLink,
+  removePersonCompanyLink,
 } from '../lib/personCompanies'
 import {
+  emitQueryIndexUpsertEvents,
   ensureOrganizationScope,
   ensureTenantScope,
   extractUndoPayload,
+  type QueryIndexEventEntry,
 } from './shared'
+import type { CustomersEventId } from '../events'
+import { E } from '#generated/entities.ids.generated'
+import type { EventBus } from '@open-mercato/events'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('customers').child({ component: 'personCompanyLinks' })
+
+// Typed against the module's declared event ids so removing or renaming the declaration in
+// `events.ts` fails the build here rather than emitting an undeclared event at runtime.
+const PROFILE_ONLY_DETACHED_EVENT: CustomersEventId = 'customers.person.company_assignment.detached'
 
 type PersonCompanyLinkSnapshot = {
   id: string
@@ -48,6 +61,65 @@ type PersonCompanyLinkUndoPayload = {
   after?: PersonCompanyLinkSnapshot | null
 }
 
+/**
+ * Snapshot of a legacy profile-only company assignment — `customer_person_profiles.company_id`
+ * set with no backing link row (#5114). It carries no link id because none exists; `kind`
+ * discriminates it from `PersonCompanyLinkSnapshot` in the delete command's undo payload.
+ */
+type PersonCompanyProfileAssignmentSnapshot = {
+  kind: 'profile-only'
+  personEntityId: string
+  companyEntityId: string
+  tenantId: string
+  organizationId: string
+}
+
+type PersonCompanyLinkDeleteSnapshot = PersonCompanyLinkSnapshot | PersonCompanyProfileAssignmentSnapshot
+
+type PersonCompanyLinkDeleteUndoPayload = {
+  before?: PersonCompanyLinkDeleteSnapshot | null
+}
+
+type PersonCompanyLinkDeleteResult = {
+  linkId: string | null
+  personEntityId: string | null
+  companyEntityId: string | null
+}
+
+function isProfileAssignmentSnapshot(
+  snapshot: PersonCompanyLinkDeleteSnapshot | null | undefined,
+): snapshot is PersonCompanyProfileAssignmentSnapshot {
+  return Boolean(snapshot) && (snapshot as PersonCompanyProfileAssignmentSnapshot).kind === 'profile-only'
+}
+
+function resolveProfileOnlyTarget(
+  parsed: PersonCompanyLinkDeleteInput,
+): { personEntityId: string; companyEntityId: string } | null {
+  if (parsed.linkId) return null
+  if (!parsed.personEntityId || !parsed.companyEntityId) return null
+  return { personEntityId: parsed.personEntityId, companyEntityId: parsed.companyEntityId }
+}
+
+function personQueryIndexEntries(
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+): QueryIndexEventEntry[] {
+  return [
+    {
+      entityType: E.customers.customer_entity,
+      recordId: person.id,
+      tenantId: person.tenantId,
+      organizationId: person.organizationId,
+    },
+    {
+      entityType: E.customers.customer_person_profile,
+      recordId: profile.id,
+      tenantId: profile.tenantId,
+      organizationId: profile.organizationId,
+    },
+  ]
+}
+
 const personCompanyLinkCrudEvents: CrudEventsConfig = {
   module: 'customers',
   entity: 'person_company_link',
@@ -576,12 +648,144 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
   },
 }
 
-const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInput, { linkId: string }> = {
+/**
+ * Detach a legacy profile-only company assignment: `customer_person_profiles.company_id`
+ * points at the company but no `customer_person_company_links` row was ever created, so
+ * there is no link row for the id-based branch to soft-delete (#5114). Running it as part
+ * of the same command keeps the audit entry, the undo token and the CRUD cache
+ * invalidation identical to a link-backed detach.
+ */
+async function detachProfileOnlyCompany(
+  em: EntityManager,
+  ctx: CommandRuntimeContext,
+  parsed: PersonCompanyLinkDeleteInput,
+  target: { personEntityId: string; companyEntityId: string },
+): Promise<PersonCompanyLinkDeleteResult> {
+  const person = await requirePersonEntity(em, target.personEntityId, parsed.tenantId, parsed.organizationId)
+  const profile = await requirePersonProfile(em, person)
+  const assignedCompany = profile.company
+  const assignedCompanyId = typeof assignedCompany === 'string' ? assignedCompany : assignedCompany?.id ?? null
+  if (assignedCompanyId !== target.companyEntityId) {
+    throw notFound('Company link not found')
+  }
+
+  await withAtomicFlush(em, [
+    () => removePersonCompanyLink(em, person, profile, target.companyEntityId),
+  ], { transaction: true })
+
+  // There is no link entity to hand to `emitCrudSideEffects`; what changed is the
+  // person's own company assignment, so reindex the person and its profile instead.
+  await emitQueryIndexUpsertEvents(ctx, personQueryIndexEntries(person, profile))
+  await emitProfileOnlyDetachedEvent(ctx, person, target.companyEntityId)
+
+  return { linkId: null, personEntityId: person.id, companyEntityId: target.companyEntityId }
+}
+
+/**
+ * Live-refresh signal for the company People tab and the person Companies tab, which the
+ * link-backed branch gets from `customers.person_company_link.deleted` via `emitCrudSideEffects`.
+ * The profile-only branch has no link row to emit that for, so it publishes the sibling
+ * `clientBroadcast` event instead (#5114). `tenantId` must travel in the payload: the event bus
+ * only forwards a broadcast event cross-process when the payload carries a tenant scope. The
+ * write is already committed, so a failed refresh signal must never fail the detach.
+ */
+async function emitProfileOnlyDetachedEvent(
+  ctx: CommandRuntimeContext,
+  person: CustomerEntity,
+  companyEntityId: string,
+): Promise<void> {
+  try {
+    const bus = ctx.container.resolve<EventBus>('eventBus')
+    await bus.emitEvent(
+      PROFILE_ONLY_DETACHED_EVENT,
+      {
+        linkId: null,
+        personEntityId: person.id,
+        companyEntityId,
+        tenantId: person.tenantId,
+        organizationId: person.organizationId,
+      },
+      { tenantId: person.tenantId, organizationId: person.organizationId },
+    )
+  } catch (err) {
+    logger.warn('Profile-only company detach broadcast failed', {
+      command: 'customers.personCompanyLinks.delete',
+      personEntityId: person.id,
+      companyEntityId,
+      err,
+    })
+  }
+}
+
+/**
+ * Undo counterpart of `detachProfileOnlyCompany`: re-point the person's legacy
+ * `profile.company` at the company it was detached from. The lookups run in the first
+ * flush phase and the assignment in the second so the encryption subscriber's
+ * re-baseline on find cannot drop the pending change (#2507).
+ */
+async function restoreProfileOnlyCompany(
+  ctx: CommandRuntimeContext,
+  before: PersonCompanyProfileAssignmentSnapshot,
+): Promise<void> {
+  const em = (ctx.container.resolve('em') as EntityManager).fork()
+  let person: CustomerEntity | null = null
+  let profile: CustomerPersonProfile | null = null
+  let company: CustomerEntity | null = null
+
+  await withAtomicFlush(em, [
+    async () => {
+      person = await findOneWithDecryption(
+        em,
+        CustomerEntity,
+        { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+        undefined,
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+      if (!person) return
+      profile = await findOneWithDecryption(
+        em,
+        CustomerPersonProfile,
+        { entity: person },
+        { populate: ['company'] },
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+      if (!profile) return
+      company = await findOneWithDecryption(
+        em,
+        CustomerEntity,
+        { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+        undefined,
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+    },
+    () => {
+      if (profile && company) profile.company = company
+    },
+  ], { transaction: true })
+
+  if (person && profile) {
+    await emitQueryIndexUpsertEvents(ctx, personQueryIndexEntries(person, profile))
+  }
+}
+
+const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInput, PersonCompanyLinkDeleteResult> = {
   id: 'customers.personCompanyLinks.delete',
   async prepare(rawInput, ctx) {
     const parsed = personCompanyLinkDeleteSchema.parse(rawInput)
+    const profileOnlyTarget = resolveProfileOnlyTarget(parsed)
+    if (profileOnlyTarget) {
+      return {
+        before: {
+          kind: 'profile-only',
+          personEntityId: profileOnlyTarget.personEntityId,
+          companyEntityId: profileOnlyTarget.companyEntityId,
+          tenantId: parsed.tenantId,
+          organizationId: parsed.organizationId,
+        } satisfies PersonCompanyProfileAssignmentSnapshot,
+      }
+    }
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const snapshot = await loadPersonCompanyLinkSnapshot(em, parsed.linkId, {
+    const snapshot = await loadPersonCompanyLinkSnapshot(em, parsed.linkId as string, {
       tenantId: ctx.auth?.tenantId ?? null,
       organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null,
     })
@@ -593,11 +797,16 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
     ensureOrganizationScope(ctx, parsed.organizationId)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const profileOnlyTarget = resolveProfileOnlyTarget(parsed)
+    if (profileOnlyTarget) {
+      return await detachProfileOnlyCompany(em, ctx, parsed, profileOnlyTarget)
+    }
+
     const link = await findOneWithDecryption(
       em,
       CustomerPersonCompanyLink,
       {
-        id: parsed.linkId,
+        id: parsed.linkId as string,
         tenantId: parsed.tenantId,
         organizationId: parsed.organizationId,
         deletedAt: null,
@@ -647,13 +856,15 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
       indexer: { entityType: 'customers:customer_person_company_link' },
     })
 
-    return { linkId: link.id }
+    return { linkId: link.id, personEntityId: personId, companyEntityId: companyId }
   },
   buildLog: async ({ result, snapshots }) => {
     const { translate } = await resolveTranslations()
-    const before = snapshots.before as PersonCompanyLinkSnapshot | undefined
+    const before = snapshots.before as PersonCompanyLinkDeleteSnapshot | undefined
     return {
       actionLabel: translate('customers.audit.personCompanyLinks.delete', 'Remove company link'),
+      // Kept as `customers.personCompanyLink` for the profile-only shape too: the company
+      // detail cache tags this resource kind, so both detach shapes must invalidate it.
       resourceKind: 'customers.personCompanyLink',
       resourceId: result.linkId,
       parentResourceKind: 'customers.person',
@@ -664,15 +875,20 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
       payload: {
         undo: {
           before: before ?? null,
-        } satisfies PersonCompanyLinkUndoPayload,
+        } satisfies PersonCompanyLinkDeleteUndoPayload,
       },
     }
   },
   undo: async ({ logEntry, ctx }) => {
-    const payload = extractUndoPayload<PersonCompanyLinkUndoPayload>(logEntry)
+    const payload = extractUndoPayload<PersonCompanyLinkDeleteUndoPayload>(logEntry)
     const before = payload?.before
     if (!before) return
 
+    if (isProfileAssignmentSnapshot(before)) {
+      await restoreProfileOnlyCompany(ctx, before)
+      return
+    }
+
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const link = await findOneWithDecryption(
       em,

package/src/modules/customers/components/detail/CompanyPeopleSection.tsx

@@ -14,6 +14,7 @@ import {
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { createTranslatorWithFallback } from '@open-mercato/shared/lib/i18n/translate'
 import { useAppEvent } from '@open-mercato/ui/backend/injection/useAppEvent'
+import type { AppEventPayload } from '@open-mercato/shared/modules/widgets/injection'
 import type { SectionAction, TabEmptyStateConfig, Translator } from './types'
 import { CreatePersonDialog } from './CreatePersonDialog'
 import { PersonCard } from './PersonCard'
@@ -322,13 +323,19 @@ export function CompanyPeopleSection({
     void loadVisiblePeople()
   }, [loadVisiblePeople])
 
-  useAppEvent('customers.person_company_link.deleted', (event) => {
+  const reloadOnCompanyDetach = React.useCallback((event: AppEventPayload) => {
     const payload = event.payload as { companyEntityId?: string | null } | null | undefined
     if (payload && payload.companyEntityId === companyId) {
       void loadVisiblePeople()
     }
   }, [companyId, loadVisiblePeople])
 
+  useAppEvent('customers.person_company_link.deleted', reloadOnCompanyDetach, [reloadOnCompanyDetach])
+  // Legacy profile-only assignments have no link row, so their detach broadcasts this sibling
+  // event instead of `customers.person_company_link.deleted` (#5114). Without it, other viewers
+  // of the same company keep listing a person who is already gone.
+  useAppEvent('customers.person.company_assignment.detached', reloadOnCompanyDetach, [reloadOnCompanyDetach])
+
   React.useEffect(() => {
     setListPage(1)
   }, [searchQuery, sortMode])

package/src/modules/customers/components/detail/PersonCompaniesSection.tsx

@@ -10,6 +10,7 @@ import { Button } from '@open-mercato/ui/primitives/button'
 import { Input } from '@open-mercato/ui/primitives/input'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { useAppEvent } from '@open-mercato/ui/backend/injection/useAppEvent'
+import type { AppEventPayload } from '@open-mercato/shared/modules/widgets/injection'
 import { CompanyCard, type EnrichedCompanyData } from './CompanyCard'
 import { useCustomerDictionary } from './hooks/useCustomerDictionary'
 import { LinkEntityDialog, type LinkEntityOption } from '../linking/LinkEntityDialog'
@@ -369,13 +370,19 @@ export function PersonCompaniesSection({
     [_personName, confirm, loadData, onChanged, personId, runWriteMutation, t, unlinkingId],
   )
 
-  useAppEvent('customers.person_company_link.deleted', (event) => {
+  const reloadOnPersonDetach = React.useCallback((event: AppEventPayload) => {
     const payload = event.payload as { personEntityId?: string | null } | null | undefined
     if (payload && payload.personEntityId === personId) {
       void loadData({ showLoading: false })
     }
   }, [personId, loadData])
 
+  useAppEvent('customers.person_company_link.deleted', reloadOnPersonDetach, [reloadOnPersonDetach])
+  // Legacy profile-only assignments have no link row, so their detach broadcasts this sibling
+  // event instead of `customers.person_company_link.deleted` (#5114). Without it, other viewers
+  // of the same person keep listing a company that is already detached.
+  useAppEvent('customers.person.company_assignment.detached', reloadOnPersonDetach, [reloadOnPersonDetach])
+
   return (
     <>
       <div className="space-y-4">

package/src/modules/customers/data/validators.ts

@@ -774,9 +774,24 @@ export const personCompanyLinkUpdateSchema = scopedSchema.extend({
   isPrimary: z.boolean(),
 })
 
-export const personCompanyLinkDeleteSchema = scopedSchema.extend({
-  linkId: uuid(),
-})
+// Two shapes are accepted, because a person can belong to a company in two ways:
+// through a `customer_person_company_links` row (`linkId`), or through a legacy
+// profile-only assignment where `customer_person_profiles.company_id` is set and no
+// link row was ever created (migrated CRM data, #5114). Both detaches go through the
+// same command so audit, undo and cache invalidation stay consistent.
+export const personCompanyLinkDeleteSchema = scopedSchema
+  .extend({
+    linkId: uuid().optional(),
+    personEntityId: uuid().optional(),
+    companyEntityId: uuid().optional(),
+  })
+  .refine(
+    (payload) => Boolean(payload.linkId) || Boolean(payload.personEntityId && payload.companyEntityId),
+    {
+      message: 'Provide either linkId or both personEntityId and companyEntityId.',
+      path: ['linkId'],
+    }
+  )
 
 export type PersonCompanyLinkCreateInput = z.infer<typeof personCompanyLinkCreateSchema>
 export type PersonCompanyLinkUpdateInput = z.infer<typeof personCompanyLinkUpdateSchema>