@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/src/runtime/confirmation-request-guardian-bridge.ts

@@ -13,15 +13,16 @@
  */
 
 import type { TrustContext } from "../daemon/trust-context.js";
+import type { CanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
-  type CanonicalGuardianRequest,
-  createCanonicalGuardianDelivery,
-} from "../memory/canonical-guardian-store.js";
+  recordApprovalCardDelivery,
+  recordGuardianRequestDeliveries,
+} from "../notifications/canonical-delivery-recorder.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
-import type { NotificationSourceChannel } from "../notifications/signal.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { getLogger } from "../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
+import { resolveCapabilities } from "./capabilities.js";
 import { getGuardianBinding } from "./channel-verification-service.js";
 
 const log = getLogger("confirmation-request-guardian-bridge");
@@ -48,7 +49,7 @@ export type BridgeConfirmationRequestResult =
   | {
       skipped: true;
       reason:
-        | "not_trusted_contact"
+        | "not_bridgeable_trust_class"
         | "no_guardian_binding"
         | "missing_guardian_identity"
         | "binding_identity_mismatch";
@@ -59,11 +60,13 @@ export type BridgeConfirmationRequestResult =
 // ---------------------------------------------------------------------------
 
 /**
- * Bridge a trusted-contact confirmation_request to a guardian.question notification.
+ * Bridge a non-guardian contact confirmation_request to a guardian.question
+ * notification.
  *
- * Only emits when the session belongs to a trusted-contact actor with a
- * resolvable guardian binding. Guardian and unknown actors are skipped — guardians
- * self-approve, and unknown actors are already fail-closed by the routing layer.
+ * Only emits when the session belongs to a trusted_contact or unverified_contact
+ * actor with a resolvable guardian binding. Guardian and unknown actors are
+ * skipped — guardians self-approve, and unknown actors are already fail-closed
+ * by the routing layer.
  *
  * Fire-and-forget safe: notification emission errors are logged but not propagated.
  */
@@ -78,10 +81,14 @@ export function bridgeConfirmationRequestToGuardian(
     assistantId = DAEMON_INTERNAL_ASSISTANT_ID,
   } = params;
 
-  // Only bridge for trusted-contact sessions. Guardians self-approve and
-  // unknown actors are fail-closed by the routing layer.
-  if (trustContext.trustClass !== "trusted_contact") {
-    return { skipped: true, reason: "not_trusted_contact" };
+  // Only bridge for actors whose sensitive tool approval escalates-and-waits.
+  // Guardians self-approve and unknown actors are fail-closed by the routing
+  // layer, so neither needs a guardian bridge.
+  if (
+    resolveCapabilities(trustContext.trustClass).sensitiveToolApproval !==
+    "escalate-and-wait"
+  ) {
+    return { skipped: true, reason: "not_bridgeable_trust_class" };
   }
 
   if (!trustContext.guardianExternalUserId) {
@@ -144,10 +151,14 @@ export function bridgeConfirmationRequestToGuardian(
     ? `Approve tool: ${toolName} — ${canonicalRequest.activityText}`
     : `Approve tool: ${toolName}`;
 
+  // The vellum delivery row is created up front in onConversationCreated so the
+  // in-app client sees it immediately; the post-resolve recorder reuses it.
+  let vellumDeliveryId: string | undefined;
+
   // Emit guardian.question notification so the guardian is alerted.
   const signalPromise = emitNotificationSignal({
     sourceEventName: "guardian.question",
-    sourceChannel: sourceChannel as NotificationSourceChannel,
+    sourceChannel,
     sourceContextId: conversationId,
     requiresConversation: true,
     attentionHints: {
@@ -157,7 +168,7 @@ export function bridgeConfirmationRequestToGuardian(
       visibleInSourceNow: false,
     },
     contextPayload: {
-      requestKind: "tool_approval" as const,
+      requestKind: "tool_approval",
       requestId: canonicalRequest.id,
       requestCode:
         canonicalRequest.requestCode ??
@@ -168,29 +179,27 @@ export function bridgeConfirmationRequestToGuardian(
       requesterIdentifier: senderLabel,
       toolName,
       questionText,
+      riskLevel: canonicalRequest.riskLevel ?? undefined,
+      commandPreview: canonicalRequest.commandPreview ?? undefined,
     },
     dedupeKey: `tc-confirmation-request:${canonicalRequest.id}`,
     onConversationCreated: (info) => {
-      createCanonicalGuardianDelivery({
+      vellumDeliveryId = recordApprovalCardDelivery({
         requestId: canonicalRequest.id,
-        destinationChannel: "vellum",
-        destinationConversationId: info.conversationId,
-      });
+        channel: "vellum",
+        conversationId: info.conversationId,
+      })?.id;
     },
   });
 
-  // Record channel deliveries from the notification pipeline (fire-and-forget).
+  // Record deliveries from the notification pipeline (fire-and-forget).
   void signalPromise
     .then((signalResult) => {
-      for (const result of signalResult.deliveryResults) {
-        if (result.channel === "vellum") continue; // handled in onConversationCreated
-        createCanonicalGuardianDelivery({
-          requestId: canonicalRequest.id,
-          destinationChannel: result.channel,
-          destinationChatId:
-            result.destination.length > 0 ? result.destination : undefined,
-        });
-      }
+      recordGuardianRequestDeliveries({
+        requestId: canonicalRequest.id,
+        deliveryResults: signalResult.deliveryResults,
+        vellumDeliveryId,
+      });
     })
     .catch((err) => {
       log.warn(

package/src/runtime/effective-capabilities.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  canActOnPrivilegedDocuments,
+  isArchiveBySenderAuthorized,
+  isUntrustedShellLockdownActive,
+} from "./effective-capabilities.js";
+
+describe("canActOnPrivilegedDocuments", () => {
+  test("guardian is privileged regardless of channel", () => {
+    expect(canActOnPrivilegedDocuments({ trustClass: "guardian" })).toBe(true);
+    expect(
+      canActOnPrivilegedDocuments({
+        trustClass: "guardian",
+        executionChannel: "telegram",
+      }),
+    ).toBe(true);
+  });
+
+  test("non-guardian is privileged only on a privileged channel", () => {
+    expect(
+      canActOnPrivilegedDocuments({
+        trustClass: "trusted_contact",
+        executionChannel: "telegram",
+      }),
+    ).toBe(false);
+    expect(
+      canActOnPrivilegedDocuments({
+        trustClass: "trusted_contact",
+        executionChannel: "vellum",
+      }),
+    ).toBe(true);
+  });
+
+  test("the vellum channel grants access even to unknown actors", () => {
+    expect(
+      canActOnPrivilegedDocuments({
+        trustClass: "unknown",
+        executionChannel: "vellum",
+      }),
+    ).toBe(true);
+    expect(canActOnPrivilegedDocuments({ trustClass: "unknown" })).toBe(false);
+  });
+});
+
+describe("isUntrustedShellLockdownActive", () => {
+  test("inactive when the lockdown flag is off", () => {
+    expect(
+      isUntrustedShellLockdownActive({
+        trustClass: "unknown",
+        lockdownEnabled: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("inactive for guardians even when the flag is on", () => {
+    expect(
+      isUntrustedShellLockdownActive({
+        trustClass: "guardian",
+        lockdownEnabled: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("active for non-unsandboxed actors when the flag is on", () => {
+    expect(
+      isUntrustedShellLockdownActive({
+        trustClass: "trusted_contact",
+        lockdownEnabled: true,
+      }),
+    ).toBe(true);
+    expect(
+      isUntrustedShellLockdownActive({
+        trustClass: "unknown",
+        lockdownEnabled: true,
+      }),
+    ).toBe(true);
+  });
+});
+
+describe("isArchiveBySenderAuthorized", () => {
+  test("any non-self authorization path suffices", () => {
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "unknown",
+        triggeredBySurfaceAction: true,
+      }),
+    ).toBe(true);
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "unknown",
+        batchAuthorizedByTask: true,
+      }),
+    ).toBe(true);
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "unknown",
+        approvedViaPrompt: true,
+      }),
+    ).toBe(true);
+  });
+
+  test("user_approved self-authorizes only for a permitted trust class", () => {
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "guardian",
+        userApproved: true,
+      }),
+    ).toBe(true);
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "trusted_contact",
+        userApproved: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("unauthorized when no path applies", () => {
+    expect(isArchiveBySenderAuthorized({ trustClass: "guardian" })).toBe(false);
+    expect(
+      isArchiveBySenderAuthorized({
+        trustClass: "trusted_contact",
+        triggeredBySurfaceAction: false,
+        userApproved: false,
+      }),
+    ).toBe(false);
+  });
+});

package/src/runtime/effective-capabilities.ts

@@ -0,0 +1,84 @@
+/**
+ * Effective capabilities — trust-class capabilities COMPOSED with runtime context.
+ *
+ * `resolveCapabilities` (`capabilities.ts`) answers "what may this trust class
+ * do" from the actor's class alone, and stays deliberately pure (no context
+ * dependencies) so it remains the single fail-closed trust boundary. Some real
+ * decisions additionally depend on runtime context — the channel a request
+ * arrived on, surface actions, task authorization, a feature flag. Those
+ * compositions belong here, in named/testable helpers, rather than re-derived
+ * inline at each call site (which scatters a single policy across the codebase).
+ *
+ * Scope: this module composes capabilities with *actor/request* context. It does
+ * not read global config or feature flags itself — callers resolve those and
+ * pass the result in (e.g. `lockdownEnabled`), keeping this layer focused on the
+ * capability composition. `resolveRoutingState` in `trust-context-resolver.ts`
+ * is the same shape (capability + guardian-route context → `promptWaitingAllowed`)
+ * and predates this module; it stays where it is.
+ */
+import type { TrustClass } from "./actor-trust-resolver.js";
+import { resolveCapabilities } from "./capabilities.js";
+
+type RawTrustClass = TrustClass | (string & {}) | undefined;
+
+/**
+ * Channels that are themselves privileged document surfaces. Actors on these get
+ * privileged document access regardless of trust class — the `vellum` first-party
+ * console is the operator's own surface, not an external contact channel.
+ */
+const PRIVILEGED_DOCUMENT_CHANNELS = new Set<string>(["vellum"]);
+
+/**
+ * Whether an actor may perform privileged (non-conversation-scoped) document
+ * operations. True when the trust class grants it OR the request arrived on a
+ * privileged channel.
+ */
+export function canActOnPrivilegedDocuments(actor: {
+  trustClass: RawTrustClass;
+  executionChannel?: string;
+}): boolean {
+  return (
+    resolveCapabilities(actor.trustClass).canAccessPrivilegedDocuments ||
+    (actor.executionChannel != null &&
+      PRIVILEGED_DOCUMENT_CHANNELS.has(actor.executionChannel))
+  );
+}
+
+/**
+ * Whether the CES shell lockdown applies to this actor. Active when the lockdown
+ * flag is enabled AND the actor's trust class cannot run an unsandboxed shell.
+ * Callers resolve the flag (`isCesShellLockdownEnabled(config)`) and pass it in.
+ */
+export function isUntrustedShellLockdownActive(actor: {
+  trustClass: RawTrustClass;
+  lockdownEnabled: boolean;
+}): boolean {
+  return (
+    actor.lockdownEnabled &&
+    !resolveCapabilities(actor.trustClass).canRunUnsandboxedShell
+  );
+}
+
+/**
+ * Whether an archive-by-sender invocation is authorized. Any one of a surface
+ * action, a task-batch authorization, or an explicit prompt approval suffices.
+ * Absent those, the actor's own `user_approved` flag only counts when its trust
+ * class may self-authorize archive-by-sender.
+ */
+export function isArchiveBySenderAuthorized(args: {
+  trustClass: RawTrustClass;
+  triggeredBySurfaceAction?: boolean;
+  batchAuthorizedByTask?: boolean;
+  approvedViaPrompt?: boolean;
+  userApproved?: boolean;
+}): boolean {
+  const selfAuthorized =
+    args.userApproved === true &&
+    resolveCapabilities(args.trustClass).canSelfAuthorizeArchiveBySender;
+  return (
+    args.triggeredBySurfaceAction === true ||
+    args.batchAuthorizedByTask === true ||
+    args.approvedViaPrompt === true ||
+    selfAuthorized
+  );
+}

package/src/runtime/guardian-reply-router.ts

@@ -30,6 +30,7 @@ import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
   getCanonicalGuardianRequestByCode,
+  getPendingCanonicalRequestByDestinationMessage,
   isRequestExpired,
   listCanonicalGuardianRequests,
 } from "../memory/canonical-guardian-store.js";
@@ -47,6 +48,7 @@ import type {
   ApprovalConversationContext,
   ApprovalConversationGenerator,
 } from "./http-types.js";
+import { parseReactionCallbackData } from "./routes/channel-route-shared.js";
 
 const log = getLogger("guardian-reply-router");
 
@@ -54,6 +56,26 @@ const log = getLogger("guardian-reply-router");
 // Types
 // ---------------------------------------------------------------------------
 
+/**
+ * How to scope a guardian's pending requests when resolving an inbound reply.
+ * The three states are mutually exclusive and named so the security-critical
+ * `blocked` cannot be confused with the absence of a hint:
+ *
+ *   - `scoped`: resolve only these request ids, and constrain request-code
+ *     routing to this set (delivery-/conversation-scoped hints).
+ *   - `blocked`: fail closed — no pending requests and no identity fallback.
+ *     The Slack cross-chat guard: a guardian's unrelated message in a chat
+ *     where no card was delivered must not resolve a request delivered
+ *     elsewhere. Explicit callbacks and request codes still work (they carry
+ *     their own request id).
+ *   - `identity-fallback`: discover pending requests by guardian identity,
+ *     conversation, or principal. The default when no scope is supplied.
+ */
+export type GuardianPendingScope =
+  | { mode: "scoped"; requestIds: string[] }
+  | { mode: "blocked" }
+  | { mode: "identity-fallback" };
+
 /** Context for an inbound message that may be a guardian reply. */
 export interface GuardianReplyContext {
   /** The raw message text (trimmed). */
@@ -66,8 +88,18 @@ export interface GuardianReplyContext {
   conversationId: string;
   /** Callback data from button presses (e.g. `apr:<requestId>:<action>`). */
   callbackData?: string;
-  /** IDs of known pending canonical requests for this guardian. */
-  pendingRequestIds?: string[];
+  /**
+   * For emoji-reaction decisions (`callbackData` of `reaction:<emoji>`): the
+   * channel-native id (e.g. Slack `ts`) of the message the reaction was
+   * attached to. Used to recover the target request from its delivery record.
+   */
+  reactedMessageTs?: string;
+  /**
+   * How to scope this guardian's pending requests (see {@link
+   * GuardianPendingScope}). Omitted is equivalent to
+   * `{ mode: "identity-fallback" }`.
+   */
+  pendingScope?: GuardianPendingScope;
   /** Conversation generator for NL classification (injected by daemon). */
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Optional channel delivery context for resolver-driven side effects. */
@@ -204,30 +236,33 @@ function parseRequestCode(
 /** Find all pending canonical requests for a guardian actor. */
 function findPendingCanonicalRequests(
   actor: ActorContext,
-  pendingRequestIds?: string[],
+  scope: GuardianPendingScope,
   conversationId?: string,
 ): CanonicalGuardianRequest[] {
+  // `blocked` fails closed: no pending requests and no identity fallback — the
+  // Slack cross-chat hijack guard.
+  if (scope.mode === "blocked") {
+    return [];
+  }
+
   let results: CanonicalGuardianRequest[];
 
-  // When explicit IDs are provided, look them up directly
-  if (pendingRequestIds) {
-    if (pendingRequestIds.length === 0) {
-      return [];
-    }
-    results = pendingRequestIds
+  if (scope.mode === "scoped") {
+    // Resolve exactly the supplied ids.
+    results = scope.requestIds
       .map(getCanonicalGuardianRequest)
       .filter((r): r is CanonicalGuardianRequest => r?.status === "pending");
   } else if (actor.actorExternalUserId) {
-    // Query by guardian identity when available
+    // identity-fallback: query by guardian identity when available
     results = listCanonicalGuardianRequests({
       status: "pending",
       guardianExternalUserId: actor.actorExternalUserId,
     });
   } else if (conversationId) {
-    // Actors without an actorExternalUserId: scope by conversationId so the NL
-    // path can discover pending requests bound to this conversation.
-    // Include guardianPrincipalId filter when available so the guardian only
-    // sees requests they are authorized to act on.
+    // identity-fallback without an actorExternalUserId: scope by conversationId
+    // so the NL path can discover pending requests bound to this conversation.
+    // Include guardianPrincipalId when available so the guardian only sees
+    // requests they are authorized to act on.
     results = listCanonicalGuardianRequests({
       status: "pending",
       conversationId,
@@ -236,9 +271,8 @@ function findPendingCanonicalRequests(
         : {}),
     });
   } else if (actor.guardianPrincipalId) {
-    // Actors with a guardianPrincipalId but no actorExternalUserId or
-    // conversationId: query by principal so desktop sessions can still
-    // discover pending guardian work via their bound principal.
+    // identity-fallback by principal: desktop sessions discover pending
+    // guardian work via their bound principal.
     results = listCanonicalGuardianRequests({
       status: "pending",
       guardianPrincipalId: actor.guardianPrincipalId,
@@ -284,22 +318,68 @@ export async function routeGuardianReply(
 ): Promise<GuardianReplyResult> {
   const {
     messageText,
+    channel,
     actor,
     conversationId,
     callbackData,
+    reactedMessageTs,
     approvalConversationGenerator,
     channelDeliveryContext,
     emissionContext,
   } = ctx;
+
+  // ── 0. Reaction decisions (emoji on a delivered approval card) ──
+  // A reaction carries an emoji plus the message it is attached to. Map the
+  // emoji to an action and recover the target request from that card's
+  // delivery record. Addressing by the reacted message disambiguates precisely
+  // even when several cards are pending in the same chat, so — unlike the
+  // text/NL paths — no clarification prompt is ever needed. `reaction_removed`
+  // never expresses intent and is filtered out before reaching the router.
+  if (
+    callbackData?.startsWith("reaction:") &&
+    !callbackData.startsWith("reaction_removed:")
+  ) {
+    const reaction = parseReactionCallbackData(callbackData);
+    const guardianChatId = channelDeliveryContext?.guardianChatId;
+    if (!reaction || !reactedMessageTs || !guardianChatId) {
+      // Unknown emoji, or missing addressing context — not an actionable
+      // approval reaction. Leave it for the caller to persist as a transcript
+      // signal (it must not trigger an agent turn).
+      return notConsumed();
+    }
+    const request = getPendingCanonicalRequestByDestinationMessage(
+      channel,
+      guardianChatId,
+      reactedMessageTs,
+    );
+    if (!request) {
+      // The reacted message is not a known pending approval card (a stray
+      // reaction, or one whose request was already resolved). Never approve
+      // off an unrecognized message.
+      return notConsumed();
+    }
+    return applyDecision(
+      request.id,
+      reaction.action,
+      actor,
+      undefined,
+      channelDeliveryContext,
+      emissionContext,
+    );
+  }
+
+  const pendingScope: GuardianPendingScope = ctx.pendingScope ?? {
+    mode: "identity-fallback",
+  };
   const pendingRequests = findPendingCanonicalRequests(
     actor,
-    ctx.pendingRequestIds,
+    pendingScope,
     conversationId,
   );
+  // Request codes carry their own id, so constrain them only under an explicit
+  // scope; under blocked/identity-fallback they still resolve cross-chat.
   const scopedPendingRequestIds =
-    ctx.pendingRequestIds && ctx.pendingRequestIds.length > 0
-      ? new Set(ctx.pendingRequestIds)
-      : null;
+    pendingScope.mode === "scoped" ? new Set(pendingScope.requestIds) : null;
 
   // ── 1. Deterministic callback parsing (button presses) ──
   // No conversationId scoping here — the guardian's reply comes from a
@@ -800,6 +880,7 @@ function resolveRequestInstructionMode(
 type CanonicalFailureReason =
   | "already_resolved"
   | "identity_mismatch"
+  | "request_misconfigured"
   | "invalid_action"
   | "expired";
 
@@ -819,6 +900,10 @@ function failureReplyText(
       return "This request has expired.";
     case "identity_mismatch":
       return "You don't have permission to decide on this request.";
+    case "request_misconfigured":
+      // The actor is authorized; the request record itself is incomplete
+      // (e.g. missing its bound principal). Do not imply a permission problem.
+      return "Something went wrong with this request on our end, so I couldn't apply your decision.";
     case "invalid_action":
       return buildGuardianInvalidActionReply(
         resolveRequestInstructionMode(request),

package/src/runtime/invite-redemption-service.ts

@@ -129,7 +129,7 @@ export function redeemInvite(params: {
     : undefined;
   const contactResult = findContactChannel({
     channelType: sourceChannel,
-    externalUserId: canonicalUserId,
+    address: canonicalUserId,
     externalChatId: externalChatId,
   });
   const existingChannel = contactResult?.channel ?? null;
@@ -164,20 +164,12 @@ export function redeemInvite(params: {
     // Sentinel error used to trigger a transaction rollback when the invite
     // was concurrently revoked/expired between pre-validation and write time.
     const STALE_INVITE = Symbol("stale_invite");
-    const canonicalMemberId = existingChannel.externalUserId
-      ? canonicalizeInboundIdentity(
-          sourceChannel as ChannelId,
-          existingChannel.externalUserId,
-        )
-      : null;
+    const canonicalMemberId = existingChannel.address;
     const canonicalCallerId = externalUserId
       ? canonicalizeInboundIdentity(sourceChannel as ChannelId, externalUserId)
       : null;
-    const memberMatchesSender = !!(
-      canonicalMemberId &&
-      canonicalCallerId &&
-      canonicalMemberId === canonicalCallerId
-    );
+    const memberMatchesSender =
+      !!canonicalCallerId && canonicalMemberId === canonicalCallerId;
     const preservedDisplayName =
       memberMatchesSender && existingContact?.displayName?.trim().length
         ? existingContact.displayName
@@ -359,7 +351,7 @@ export function redeemVoiceInviteCode(params: {
     callerExternalUserId;
   const voiceContactResult = findContactChannel({
     channelType: "phone",
-    externalUserId: canonicalCallerId,
+    address: canonicalCallerId,
   });
   const existingVoiceChannel = voiceContactResult?.channel ?? null;
   const voiceContact = voiceContactResult?.contact ?? null;
@@ -511,7 +503,7 @@ export function redeemInviteByCode(params: {
     : undefined;
   const contactResult = findContactChannel({
     channelType: sourceChannel,
-    externalUserId: canonicalUserId,
+    address: canonicalUserId,
     externalChatId: externalChatId,
   });
   const existingChannel = contactResult?.channel ?? null;
@@ -542,20 +534,12 @@ export function redeemInviteByCode(params: {
   // an invite use atomically.
   if (existingChannel && !targetMismatch) {
     const STALE_INVITE_REACTIVATE = Symbol("stale_invite_reactivate");
-    const canonicalMemberId = existingChannel.externalUserId
-      ? canonicalizeInboundIdentity(
-          sourceChannel as ChannelId,
-          existingChannel.externalUserId,
-        )
-      : null;
+    const canonicalMemberId = existingChannel.address;
     const canonicalCallerId = externalUserId
       ? canonicalizeInboundIdentity(sourceChannel as ChannelId, externalUserId)
       : null;
-    const memberMatchesSender = !!(
-      canonicalMemberId &&
-      canonicalCallerId &&
-      canonicalMemberId === canonicalCallerId
-    );
+    const memberMatchesSender =
+      !!canonicalCallerId && canonicalMemberId === canonicalCallerId;
     const preservedDisplayName =
       memberMatchesSender && existingContact?.displayName?.trim().length
         ? existingContact.displayName