@open-mercato/core 0.6.5-develop.4384.1.ce2ec6eaaa → 0.6.5-develop.4397.1.9a65481757

package/src/modules/communication_channels/subscribers/outbound-bridge.ts

@@ -0,0 +1,175 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { ChannelThreadMapping, CommunicationChannel, MessageChannelLink } from '../data/entities'
+import { Message } from '../../messages/data/entities'
+import { COMMUNICATION_CHANNELS_QUEUES, getCommunicationChannelsQueue } from '../lib/queue'
+import type { OutboundDeliveryPayload } from '../workers/outbound-delivery'
+
+/**
+ * Subscriber: outbound bridge.
+ *
+ * Listens to `messages.message.sent` and, when the Message lives in a channel-linked
+ * thread, enqueues a delivery job to the `communication-channels-outbound` queue.
+ *
+ * Per the pre-implementation analysis we **re-fetch the Message by ID** rather than
+ * trusting the event payload — this keeps the subscriber decoupled from the
+ * `messages.message.sent` payload shape, so any future addition/removal of fields
+ * in the messages module doesn't break this bridge.
+ *
+ * Idempotency: we check for an existing `MessageChannelLink` with `direction='outbound'`
+ * and `deliveryStatus IN ('queued','pending','sent','delivered','read')`. If found, we
+ * skip — the message is already delivered or has a delivery in flight. Including the
+ * in-flight states ('queued'/'pending') stops a replayed `messages.message.sent` from
+ * enqueueing a second delivery job while the worker is mid-send. The command-side check
+ * is the authoritative gate, but this cheap subscriber-level check avoids redundant jobs.
+ *
+ * Internal-only messages (no `ChannelThreadMapping` for the threadId) are skipped
+ * silently — this is the expected steady-state for the majority of platform messages.
+ */
+export const metadata = {
+  event: 'messages.message.sent',
+  persistent: true,
+  id: 'communication_channels:outbound-bridge',
+}
+
+type MessageSentPayload = {
+  messageId: string
+  senderUserId?: string
+  recipientUserIds?: string[]
+  sendViaEmail?: boolean
+  externalEmail?: string | null
+  tenantId: string
+  organizationId?: string | null
+}
+
+type SubscriberContext = {
+  /** Canonical event-bus context: `resolve` is exposed directly (no `.container` wrapper). */
+  resolve: <T = unknown>(name: string) => T
+  /** Some callers wrap in a `container` — supported for forward-compat. */
+  container?: { resolve: <T = unknown>(name: string) => T }
+}
+
+function resolveFromCtx<T = unknown>(ctx: SubscriberContext, name: string): T {
+  if (typeof ctx?.resolve === 'function') return ctx.resolve<T>(name)
+  if (ctx?.container && typeof ctx.container.resolve === 'function') {
+    return ctx.container.resolve<T>(name)
+  }
+  throw new Error(`outbound-bridge: subscriber context has no resolver (looking for '${name}')`)
+}
+
+export default async function handler(
+  payload: MessageSentPayload,
+  ctx: SubscriberContext,
+): Promise<void> {
+  if (!payload?.messageId || !payload.tenantId) {
+    return
+  }
+
+  const em = (resolveFromCtx<EntityManager>(ctx, 'em')).fork()
+  const dscope = {
+    tenantId: payload.tenantId,
+    organizationId: payload.organizationId ?? null,
+  }
+
+  // (a) Re-fetch the Message — no payload-shape coupling.
+  const message = await findOneWithDecryption(
+    em,
+    Message,
+    {
+      id: payload.messageId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+      deletedAt: null,
+    },
+    undefined,
+    dscope,
+  )
+  if (!message) return
+  if (message.sourceEntityType === 'communication_channels.send_as_user') {
+    return
+  }
+  // Inbound ingest path: when `ingest-inbound-message` composes a new platform
+  // Message for an incoming email, the messages module also emits
+  // `messages.message.sent` (the Message row is fresh and marked sent). Without
+  // this guard, we'd treat it as outbound and queue a redundant SMTP delivery —
+  // which fails because inbound MCLs carry recipient info in `channelPayload`,
+  // not `channelMetadata`, and the failure marker then leaks back onto the
+  // inbound link itself.
+  if (message.sourceEntityType === 'communication_channels.external_conversation') {
+    return
+  }
+  if (!message.threadId) return // Internal-only; no channel routing.
+
+  // (b) Look up the channel mapping by threadId.
+  const mapping = await findOneWithDecryption(
+    em,
+    ChannelThreadMapping,
+    {
+      messageThreadId: message.threadId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    },
+    undefined,
+    dscope,
+  )
+  if (!mapping) return // Internal-only thread; skip silently.
+
+  // (c) Idempotency — skip if already delivered.
+  const existingLink = await findOneWithDecryption(
+    em,
+    MessageChannelLink,
+    {
+      messageId: message.id,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    },
+    undefined,
+    dscope,
+  )
+  if (
+    existingLink &&
+    (existingLink.deliveryStatus === 'queued' ||
+      existingLink.deliveryStatus === 'pending' ||
+      existingLink.deliveryStatus === 'sent' ||
+      existingLink.deliveryStatus === 'delivered' ||
+      existingLink.deliveryStatus === 'read')
+  ) {
+    return
+  }
+
+  // (c2) Per-user ownership gate. Outbound delivery sends with the CHANNEL
+  // OWNER's credentials (workers/outbound-delivery → deliver-outbound-message),
+  // so we may only bridge a platform message into a per-user channel when the
+  // message's sender OWNS that channel. Tenant-wide channels (userId == null —
+  // shared inboxes) accept any sender. Without this, composing into another
+  // user's channel-linked thread would send from their connected account
+  // (impersonation). Mirrors lib/send-as-user and the reaction ownership gate.
+  const channel = await findOneWithDecryption(
+    em,
+    CommunicationChannel,
+    {
+      id: mapping.channelId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+      deletedAt: null,
+    },
+    undefined,
+    dscope,
+  )
+  if (!channel) return
+  if (channel.userId != null && channel.userId !== message.senderUserId) {
+    return
+  }
+
+  // (d) Enqueue the delivery worker.
+  const queue = getCommunicationChannelsQueue(COMMUNICATION_CHANNELS_QUEUES.outbound)
+  const job: OutboundDeliveryPayload = {
+    messageId: message.id,
+    scope: {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    },
+    attempt: 1,
+  }
+  await queue.enqueue(job as unknown as Record<string, unknown>)
+}

package/src/modules/communication_channels/subscribers/user-deleted-cascade.ts

@@ -0,0 +1,100 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '../data/entities'
+
+/**
+ * Subscriber: cascade-disconnect a user's communication channels when the user
+ * is deleted (`auth.user.deleted` event).
+ *
+ * Why a subscriber, not a foreign-key CASCADE: per root `AGENTS.md`, modules
+ * don't form direct ORM relationships across the auth module boundary —
+ * `CommunicationChannel.userId` is a plain `uuid` column, not a FK. The
+ * cascade must therefore happen at the event-bridge layer, here, in response
+ * to the auth module's lifecycle event.
+ *
+ * Effects per matched channel:
+ *   1. `status = 'disconnected'`        — stops the polling worker (slice 3b
+ *                                          skips channels not in `connected`).
+ *   2. `is_active = false`              — hides the channel from the hub admin
+ *                                          UI and stops adapter resolution.
+ *   3. `credentials_ref = null`         — orphans the encrypted credentials
+ *                                          blob in `integration_credentials`
+ *                                          (the integrations module's own
+ *                                          retention policy then sweeps it).
+ *   4. `last_error = 'user-deleted'`    — diagnostic breadcrumb.
+ *
+ * The channel row itself is NOT hard-deleted — keeping it preserves the audit
+ * trail of which user owned it and the conversation history that still lives
+ * in `external_messages` / `messages`. A future tenant-level GDPR sweep can
+ * hard-delete on a schedule.
+ *
+ * Idempotency: the update is conditional on `status != 'disconnected'`, so
+ * replays from the event bus are no-ops.
+ */
+export const metadata = {
+  event: 'auth.user.deleted',
+  persistent: true,
+  id: 'communication_channels:user-deleted-cascade',
+}
+
+type AuthUserDeletedPayload = {
+  userId: string
+  tenantId?: string
+  organizationId?: string | null
+}
+
+type SubscriberContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export default async function handler(
+  payload: AuthUserDeletedPayload,
+  ctx: SubscriberContext,
+): Promise<void> {
+  if (!payload || typeof payload.userId !== 'string' || !payload.userId) {
+    return
+  }
+  // tenantId MUST be present: an unscoped cascade would touch rows in arbitrary
+  // tenants if two tenants ever happened to share a userId (impossible under
+  // UUIDv4 but possible after backup-restore). Fail-closed: skip when missing
+  // and let an out-of-band sweep clean up.
+  if (typeof payload.tenantId !== 'string' || !payload.tenantId) {
+    return
+  }
+  const em = (ctx.resolve('em') as EntityManager).fork()
+
+  const channels = await findWithDecryption(
+    em,
+    CommunicationChannel,
+    {
+      userId: payload.userId,
+      tenantId: payload.tenantId,
+      ...(payload.organizationId !== undefined
+        ? { organizationId: payload.organizationId ?? null }
+        : {}),
+      deletedAt: null,
+    },
+    undefined,
+    {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    },
+  )
+  if (channels.length === 0) return
+
+  let touched = 0
+  for (const channel of channels) {
+    // Already disconnected → idempotent skip.
+    if (channel.status === 'disconnected' && channel.isActive === false) continue
+    channel.status = 'disconnected'
+    channel.isActive = false
+    channel.credentialsRef = null
+    channel.lastError = 'user-deleted'
+    channel.isPrimary = false
+    channel.lastPolledAt = new Date()
+    touched += 1
+  }
+  if (touched > 0) {
+    await em.flush()
+  }
+}

package/src/modules/communication_channels/widgets/components.ts

@@ -0,0 +1,36 @@
+import type { ComponentOverride } from '@open-mercato/shared/modules/widgets/component-registry'
+
+/**
+ * Component override scaffold for the Communications Hub.
+ *
+ * Phase 4 of the email integration spec (`2026-05-21-email-integration-foundation`)
+ * adds a `MessagesThreadDetailHeader` override for `channelType=email`. The shipping
+ * Messages module renders the header via `MainMessageHeader` and does not yet expose
+ * a registered component id — the header is rendered as a regular React component
+ * in `MessageDetailPageClient.tsx`. The override mechanism (this file, plus the
+ * `widgets/components.ts` auto-discovery convention) is wired and ready for the
+ * Messages module to opt in by registering the component.
+ *
+ * Today, email-specific affordances (subject / Cc list / attachment count / Gmail
+ * labels) are delivered to the Messages thread view via the
+ * existing `detail:messages:message:body:after` injection spot's
+ * `channel-payload-renderer` widget (slice 2e/2f). That widget renders the same
+ * affordances the spec lists as header content, just below the header rather than
+ * inside it. Surfacing them inside the header is the v2 upgrade path.
+ *
+ * Forward-compatible handle ids the hub will target once Messages exposes them:
+ *   - `section:messages.detail.header`   — primary slot; the email override
+ *                                         wraps it with the email banner above
+ *                                         the default header.
+ *   - `data-table:messages:row`          — secondary slot; email-channel rows
+ *                                         get a small inline preview of the
+ *                                         first-from name + envelope icon.
+ *
+ * Until Messages calls `registerComponent({ id: 'section:messages.detail.header', ... })`,
+ * this file exports an empty array — the hub honors the override-mechanism
+ * contract (downstream apps can target hub-side handles) without inventing
+ * fictional component ids the Messages module doesn't surface.
+ */
+export const componentOverrides: ComponentOverride[] = []
+
+export default componentOverrides

package/src/modules/communication_channels/widgets/injection/channel-badge/widget.client.tsx

@@ -0,0 +1,38 @@
+'use client'
+
+import * as React from 'react'
+import { Tag } from '@open-mercato/ui/primitives/tag'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+
+type ChannelEnrichment = {
+  providerKey?: string
+  channelType?: string
+  direction?: 'inbound' | 'outbound' | string
+  deliveryStatus?: string | null
+}
+
+export type ChannelBadgeProps = {
+  channel: ChannelEnrichment | null | undefined
+}
+
+/**
+ * Pure presentational badge — renders the channel provider/type as a `<Tag>`
+ * pill. The host (declarative column injection — see `widget.ts`) feeds the
+ * `_channel` enrichment in.
+ */
+export default function ChannelBadgeWidget({ channel }: ChannelBadgeProps) {
+  const t = useT()
+  if (!channel) return null
+
+  const providerLabel = channel.providerKey ?? channel.channelType ?? ''
+  const variant: 'success' | 'info' = channel.direction === 'outbound' ? 'info' : 'success'
+
+  return (
+    <Tag variant={variant} dot>
+      {t(
+        `communication_channels.channel.providers.${providerLabel}`,
+        providerLabel,
+      )}
+    </Tag>
+  )
+}

package/src/modules/communication_channels/widgets/injection/channel-badge/widget.ts

@@ -0,0 +1,51 @@
+import * as React from 'react'
+import type { InjectionColumnWidget } from '@open-mercato/shared/modules/widgets/injection'
+import ChannelBadgeWidget from './widget.client'
+
+/**
+ * Channel badge — renders the channel type/provider icon + label as a `<Tag>`
+ * pill in the messages DataTable's columns spot (`data-table:messages:columns`).
+ *
+ * DataTable's column-injection contract requires a declarative `columns` array
+ * of `InjectionColumnDefinition` — the registry filters out widgets that don't
+ * expose `columns`. The cell renderer is a React component that reads the
+ * `_channel` enrichment field added by `messageChannelEnricher`.
+ *
+ * Round-1/round-2 review trail: round-1 shipped this as an
+ * `InjectionWidgetModule` with a top-level `Widget` component, which DataTable
+ * silently skipped (`if (!('columns' in widget)) continue`). Round-2 R2-H6 / F7
+ * (2026-05-26) converted it to the declarative column shape.
+ *
+ * Provider packages can override this widget via UMES component replacement
+ * (`section:communication_channels.channel-badge`) to render brand-specific
+ * badges (Slack logo, WhatsApp green badge, etc.).
+ */
+const widget: InjectionColumnWidget = {
+  metadata: {
+    id: 'communication_channels.injection.channel-badge',
+    title: 'Channel badge',
+    description:
+      'Renders a channel-type/provider badge inline in the messages list. Visible whenever a message has an associated MessageChannelLink (= the message was bridged from or to an external channel).',
+    features: ['communication_channels.view'],
+    priority: 100,
+    enabled: true,
+  },
+  columns: [
+    {
+      id: 'communication_channels.channel-badge',
+      header: 'communication_channels.columns.provider',
+      accessorKey: '_channel',
+      size: 140,
+      cell: ({ getValue }) => {
+        const channel = getValue() as
+          | { providerKey?: string; channelType?: string; direction?: string; deliveryStatus?: string | null }
+          | null
+          | undefined
+        if (!channel) return null
+        return React.createElement(ChannelBadgeWidget, { channel })
+      },
+    },
+  ],
+}
+
+export default widget

package/src/modules/communication_channels/widgets/injection/channel-info-panel/widget.client.tsx

@@ -0,0 +1,278 @@
+'use client'
+
+import * as React from 'react'
+import type { InjectionWidgetComponentProps } from '@open-mercato/shared/modules/widgets/injection'
+import { hasFeature } from '@open-mercato/shared/security/features'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@open-mercato/ui/primitives/select'
+
+type ChannelEnrichment = {
+  providerKey: string
+  channelType: string
+  direction: 'inbound' | 'outbound' | string
+  deliveryStatus: string | null
+}
+
+type ChannelContactEnrichment = {
+  contactPersonId: string | null
+  assignedUserId: string | null
+  subject: string | null
+}
+
+type MessageWithChannelContext = Record<string, unknown> & {
+  id?: string
+  threadId?: string | null
+  _channel?: ChannelEnrichment | null
+  _channelContact?: ChannelContactEnrichment | null
+}
+
+type WidgetContext = Record<string, unknown> & {
+  /**
+   * Set when the host (e.g. message detail page) provides the current user's
+   * feature grants. The reassignment editor is hidden when
+   * `communication_channels.assign` is not present. Wildcard grants
+   * (`*` and `communication_channels.*`) are honored too.
+   */
+  userFeatures?: string[]
+}
+
+type UserOption = { id: string; label: string }
+
+const FEATURE_GATE = 'communication_channels.assign'
+const CHANNEL_INFO_MUTATION_CONTEXT_ID = 'communication-channels-info-panel'
+// Radix Select reserves '' for "no selection"; use a sentinel for Unassigned.
+const UNASSIGNED_VALUE = '__unassigned__'
+
+type ChannelInfoMutationContext = {
+  formId: string
+  resourceKind: string
+  resourceId: string
+  retryLastMutation: () => Promise<boolean>
+}
+
+export default function ChannelInfoPanelWidget({
+  data,
+  context,
+}: InjectionWidgetComponentProps<WidgetContext, MessageWithChannelContext>) {
+  const t = useT()
+  const channel = data?._channel ?? null
+  const contact = data?._channelContact ?? null
+  const { runMutation, retryLastMutation } = useGuardedMutation<ChannelInfoMutationContext>({
+    contextId: CHANNEL_INFO_MUTATION_CONTEXT_ID,
+    blockedMessage: t('ui.forms.flash.saveBlocked', 'Save blocked by validation'),
+  })
+
+  const canReassign = hasFeature(context?.userFeatures ?? [], FEATURE_GATE)
+
+  const [assignedUserId, setAssignedUserId] = React.useState<string | null>(
+    contact?.assignedUserId ?? null,
+  )
+  const [savingAssignee, setSavingAssignee] = React.useState(false)
+  const [users, setUsers] = React.useState<UserOption[]>([])
+  const [usersLoaded, setUsersLoaded] = React.useState(false)
+
+  React.useEffect(
+    () => setAssignedUserId(contact?.assignedUserId ?? null),
+    [contact?.assignedUserId],
+  )
+
+  const loadUsers = React.useCallback(async () => {
+    if (usersLoaded || !canReassign) return
+    const response = await apiCall<{
+      items?: Array<{ id: string; email?: string | null; name?: string | null }>
+    }>('/api/auth/users?page=1&pageSize=50', {
+      // Opportunistic dropdown-options fetch: a user may hold
+      // `communication_channels.assign` without `auth.users.list`. Suppress the
+      // global 403/401 redirect + forbidden flash so the page degrades to an
+      // empty assignee list instead of bouncing the whole browser to /login.
+      headers: { 'x-om-forbidden-redirect': '0', 'x-om-unauthorized-redirect': '0' },
+    }).catch(() => null)
+    if (!response || !response.ok) {
+      setUsersLoaded(true)
+      return
+    }
+    const items = (response.result?.items ?? []).flatMap<UserOption>((u) => {
+      if (!u?.id) return []
+      const label =
+        (typeof u.name === 'string' && u.name.trim().length > 0 && u.name.trim()) ||
+        (typeof u.email === 'string' && u.email.trim().length > 0 && u.email.trim()) ||
+        u.id
+      return [{ id: u.id, label }]
+    })
+    setUsers(items)
+    setUsersLoaded(true)
+  }, [canReassign, usersLoaded])
+
+  const reassign = React.useCallback(
+    async (nextAssignedUserId: string | null) => {
+      const threadId = data?.threadId
+      if (!threadId) {
+        flash(
+          t(
+            'communication_channels.infoPanel.noThread',
+            'This message is not on a thread; reassignment unavailable.',
+          ),
+          'error',
+        )
+        return
+      }
+      setSavingAssignee(true)
+      try {
+        const response = await runMutation({
+          operation: () => apiCall<{ assignedUserId: string | null }>(
+            `/api/communication_channels/threads/${encodeURIComponent(threadId)}/assign`,
+            {
+              method: 'PUT',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ assignedUserId: nextAssignedUserId }),
+            },
+          ),
+          context: {
+            formId: CHANNEL_INFO_MUTATION_CONTEXT_ID,
+            resourceKind: 'communication_channels.thread',
+            resourceId: threadId,
+            retryLastMutation,
+          },
+          mutationPayload: { assignedUserId: nextAssignedUserId },
+        })
+        if (!response.ok) {
+          const body = response.result as { error?: string } | undefined
+          flash(
+            body?.error ??
+              t('communication_channels.infoPanel.reassignError', 'Reassignment failed'),
+            'error',
+          )
+          return
+        }
+        setAssignedUserId(nextAssignedUserId)
+        flash(
+          t('communication_channels.infoPanel.reassignSuccess', 'Conversation reassigned.'),
+          'success',
+        )
+      } catch (err) {
+        flash(
+          err instanceof Error
+            ? err.message
+            : t('communication_channels.infoPanel.reassignError', 'Reassignment failed'),
+          'error',
+        )
+      } finally {
+        setSavingAssignee(false)
+      }
+    },
+    [data?.threadId, retryLastMutation, runMutation, t],
+  )
+
+  if (!channel) return null
+
+  return (
+    <aside
+      className="rounded-md border bg-card p-4 text-sm"
+      aria-label={t('communication_channels.infoPanel.aria', 'Channel info')}
+    >
+      <header className="mb-2 text-overline text-muted-foreground">
+        {t('communication_channels.infoPanel.title', 'Channel info')}
+      </header>
+      <dl className="grid grid-cols-2 gap-1 text-xs">
+        <dt className="text-muted-foreground">
+          {t('communication_channels.infoPanel.provider', 'Provider')}
+        </dt>
+        <dd>{channel.providerKey}</dd>
+
+        <dt className="text-muted-foreground">
+          {t('communication_channels.infoPanel.type', 'Type')}
+        </dt>
+        <dd>{channel.channelType}</dd>
+
+        <dt className="text-muted-foreground">
+          {t('communication_channels.infoPanel.direction', 'Direction')}
+        </dt>
+        <dd>{channel.direction}</dd>
+
+        {channel.deliveryStatus ? (
+          <>
+            <dt className="text-muted-foreground">
+              {t('communication_channels.infoPanel.status', 'Status')}
+            </dt>
+            <dd>{channel.deliveryStatus}</dd>
+          </>
+        ) : null}
+
+        {contact?.contactPersonId ? (
+          <>
+            <dt className="text-muted-foreground">
+              {t('communication_channels.infoPanel.contactPerson', 'CRM contact')}
+            </dt>
+            <dd className="truncate" title={contact.contactPersonId}>
+              {contact.contactPersonId}
+            </dd>
+          </>
+        ) : null}
+
+        {contact?.subject ? (
+          <>
+            <dt className="text-muted-foreground">
+              {t('communication_channels.infoPanel.subject', 'Subject')}
+            </dt>
+            <dd className="col-span-2 truncate" title={contact.subject}>
+              {contact.subject}
+            </dd>
+          </>
+        ) : null}
+
+        <dt className="text-muted-foreground">
+          {t('communication_channels.infoPanel.assignedTo', 'Assigned to')}
+        </dt>
+        <dd className="col-span-1">
+          {canReassign ? (
+            <Select
+              value={assignedUserId ?? UNASSIGNED_VALUE}
+              onValueChange={(value) =>
+                void reassign(value === UNASSIGNED_VALUE ? null : value)
+              }
+              onOpenChange={(isOpen) => {
+                if (isOpen) void loadUsers()
+              }}
+              disabled={savingAssignee || !data?.threadId}
+            >
+              <SelectTrigger
+                size="xs"
+                aria-label={t('communication_channels.infoPanel.assignedTo', 'Assigned to')}
+              >
+                <SelectValue
+                  placeholder={t('communication_channels.infoPanel.unassigned', 'Unassigned')}
+                />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value={UNASSIGNED_VALUE}>
+                  {t('communication_channels.infoPanel.unassigned', 'Unassigned')}
+                </SelectItem>
+                {assignedUserId && !users.some((u) => u.id === assignedUserId) ? (
+                  <SelectItem value={assignedUserId}>{assignedUserId}</SelectItem>
+                ) : null}
+                {users.map((user) => (
+                  <SelectItem key={user.id} value={user.id}>
+                    {user.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          ) : (
+            <span className="truncate" title={assignedUserId ?? ''}>
+              {assignedUserId ?? t('communication_channels.infoPanel.unassigned', 'Unassigned')}
+            </span>
+          )}
+        </dd>
+      </dl>
+    </aside>
+  )
+}