@open-mercato/core 0.6.8-develop.7012.1.1dbd6f5fbd → 0.6.8-develop.7015.1.af90a2ddc7

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>

package/src/modules/customers/events.ts

@@ -78,6 +78,11 @@ const events = [
   { id: 'customers.person_company_link.created', label: 'Person Linked To Company', entity: 'person_company_link', category: 'crud', clientBroadcast: true },
   { id: 'customers.person_company_link.updated', label: 'Person-Company Link Updated', entity: 'person_company_link', category: 'crud', clientBroadcast: true },
   { id: 'customers.person_company_link.deleted', label: 'Person Unlinked From Company', entity: 'person_company_link', category: 'crud', clientBroadcast: true },
+  // Legacy profile-only company assignments (`customer_person_profiles.company_id` set with no
+  // backing link row, #5114) have no link entity, so detaching one cannot honestly emit
+  // `customers.person_company_link.deleted` — that event's payload promises a link id that never
+  // existed. This sibling carries the same live-refresh signal for that shape instead.
+  { id: 'customers.person.company_assignment.detached', label: 'Legacy Company Assignment Detached', entity: 'person_company_link', category: 'lifecycle', clientBroadcast: true },
 
   // ── Email integration (2026-05-27) ────────────────────────────────────────
   { id: 'customers.email.linked', label: 'Email Linked To Person', entity: 'email_link', category: 'lifecycle', clientBroadcast: true },

package/src/modules/customers/lib/personCompanies.ts

@@ -56,6 +56,136 @@ async function requireCompany(
   return company
 }
 
+export type CompanyPersonUnionEntry = {
+  entity: CustomerEntity
+  profile: CustomerPersonProfile | null
+  linkedAt: string | null
+}
+
+/**
+ * Resolve "people belonging to this company" as the union of active
+ * `CustomerPersonCompanyLink` rows and `CustomerPersonProfile.company`
+ * profile-only assignments (data that never got a link row, e.g. from
+ * migrated CRM imports). This is the single source of truth for both the
+ * company People tab list and its badge count — see #5114.
+ */
+export async function loadCompanyPeopleUnion(
+  em: EntityManager,
+  company: CustomerEntity,
+  scope: { tenantId?: string | null; organizationId?: string | null },
+): Promise<CompanyPersonUnionEntry[]> {
+  const decryptionScope = {
+    tenantId: scope.tenantId ?? company.tenantId ?? null,
+    organizationId: scope.organizationId ?? company.organizationId ?? null,
+  }
+  const relatedPeopleById = new Map<string, CompanyPersonUnionEntry>()
+
+  const companyLinkWhere = await withActiveCustomerPersonCompanyLinkFilter(
+    em,
+    { company: company.id, organizationId: company.organizationId, tenantId: company.tenantId },
+    'customers.companies.loadCompanyPeopleUnion',
+  )
+  const companyLinks = filterActivePersonCompanyLinks(
+    await findWithDecryption(
+      em,
+      CustomerPersonCompanyLink,
+      companyLinkWhere,
+      { populate: ['person', 'person.personProfile'], orderBy: { isPrimary: 'desc', createdAt: 'asc' } },
+      decryptionScope,
+    ),
+  )
+  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'] },
+    decryptionScope,
+  )
+  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,
+      })
+    }
+  })
+
+  return Array.from(relatedPeopleById.values())
+}
+
+/**
+ * Count-only sibling of `loadCompanyPeopleUnion` for the company People badge, which
+ * needs the size of the union and nothing else. Both queries project just the foreign
+ * key column and push the `kind: 'person'` / `deletedAt: null` predicates into the
+ * WHERE clause, so no person row is hydrated and no PII is decrypted to produce a
+ * number — `findWithDecryption` is deliberately not used here because the projections
+ * select no encrypted column.
+ */
+export async function countCompanyPeopleUnion(
+  em: EntityManager,
+  company: CustomerEntity,
+): Promise<number> {
+  const personIds = new Set<string>()
+
+  const companyLinkWhere = await withActiveCustomerPersonCompanyLinkFilter(
+    em,
+    {
+      company: company.id,
+      organizationId: company.organizationId,
+      tenantId: company.tenantId,
+      person: { kind: 'person', deletedAt: null },
+    },
+    'customers.companies.countCompanyPeopleUnion',
+  )
+  const companyLinks = filterActivePersonCompanyLinks(
+    await em.find(CustomerPersonCompanyLink, companyLinkWhere as any, {
+      fields: ['person', 'deletedAt'],
+    } as any),
+  )
+  companyLinks.forEach((link) => {
+    const personId = typeof link.person === 'string' ? link.person : link.person?.id
+    if (personId) personIds.add(personId)
+  })
+
+  const profiles = await em.find(
+    CustomerPersonProfile,
+    {
+      company: company.id,
+      tenantId: company.tenantId,
+      organizationId: company.organizationId,
+      entity: { kind: 'person', deletedAt: null },
+    } as any,
+    { fields: ['entity'] } as any,
+  )
+  profiles.forEach((entry) => {
+    const entity = entry.entity as CustomerEntity | string | null
+    const entityId = typeof entity === 'string' ? entity : entity?.id
+    if (entityId) personIds.add(entityId)
+  })
+
+  return personIds.size
+}
+
 export async function loadPersonCompanyLinks(
   em: EntityManager,
   person: CustomerEntity,
@@ -298,7 +428,12 @@ export async function removePersonCompanyLink(
 
   if (!link) {
     if (profile.company && typeof profile.company !== 'string' && profile.company.id === linkId) {
-      profile.company = null
+      // Profile-only assignment: no link row backs it, so only the legacy field is
+      // cleared. It must keep mirroring the primary link the way every other detach
+      // path leaves it, so promote a remaining primary link instead of nulling blindly.
+      const primary = existingLinks.find((entry) => entry.isPrimary) ?? null
+      const primaryCompany = primary ? resolveLinkedCompany(primary) : null
+      profile.company = primaryCompany ?? null
       return
     }
     throw notFound('Company link not found')