@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/runtime/routes/credential-prompt-routes.ts

@@ -50,6 +50,20 @@ const CredentialPromptParams = z.object({
 // Response type (shared with CLI consumer)
 // ---------------------------------------------------------------------------
 
+/**
+ * Appended to every terminal success message.
+ *
+ * The prompt blocks until the user answers, so by the time a caller reads the
+ * result the secure input is already gone from the UI. A bare `ok: true` reads
+ * as "the prompt opened successfully", which leads a model to follow up with
+ * "the prompt is open, paste your value there" — pointing the user at a surface
+ * that has already closed. The user, having just submitted, re-answers a prompt
+ * that never reappears, and the flow loops. State the close explicitly so the
+ * only available reading is the correct one.
+ */
+const PROMPT_CLOSED_NOTICE =
+  "The secure prompt has closed — do not ask the user to enter this value again.";
+
 export type CredentialPromptResult = {
   ok: boolean;
   /**
@@ -204,19 +218,26 @@ async function handleCredentialPrompt({ body = {} }: RouteHandlerArgs) {
       ok: true,
       service: validated.service,
       field: validated.field,
-      message: `One-time credential provided for ${validated.service}/${validated.field}. The value was not saved and will be consumed by the next operation.`,
+      message: `One-time credential provided for ${validated.service}/${validated.field}. The value was not saved and will be consumed by the next operation. ${PROMPT_CLOSED_NOTICE}`,
     };
   }
 
+  // A Slack channel token is routed through the channel config rather than the
+  // vault, so its connection status is what describes the outcome; every other
+  // credential reports the vault write.
   const slackStatus = persisted.slackChannel
     ? formatSlackChannelStatus(persisted.slackChannel).trim()
     : "";
+  const outcomeSummary =
+    slackStatus.length > 0
+      ? slackStatus
+      : `Credential received from the user and stored as ${validated.service}/${validated.field}.`;
 
   return {
     ok: true,
     service: validated.service,
     field: validated.field,
-    message: slackStatus.length > 0 ? slackStatus : undefined,
+    message: `${outcomeSummary} ${PROMPT_CLOSED_NOTICE}`,
   };
 }
 

package/src/runtime/routes/debug-routes.ts

@@ -50,7 +50,10 @@ function getDebugInfo() {
   // Debug view counts every standard conversation, archived or not, so the
   // diagnostics report doesn't undercount after the route-level default
   // moved to "active".
-  const conversationCount = countConversations("standard", "all");
+  const conversationCount = countConversations({
+    conversationType: "standard",
+    archiveStatus: "all",
+  });
   const memoryItemCount = getMemoryItemCount();
   const dbSizeBytes = getDatabaseSizeBytes();
 

package/src/runtime/routes/default-provider-routes.ts

@@ -25,22 +25,18 @@ import {
   DEFAULT_PROVIDER_CHOICES,
   DefaultProviderSchema,
 } from "../../config/schemas/llm.js";
-import { computeConnectionAvailability } from "../../providers/inference/connection-availability.js";
+import {
+  computeConnectionAvailability,
+  CONNECTION_AVAILABILITY_STATUSES,
+} from "../../providers/inference/connection-availability.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const availabilitySchema = z.object({
-  status: z.enum([
-    "ok",
-    "missing_default",
-    "missing_connection",
-    "missing_credential",
-    "provider_mismatch",
-    "unsupported_auth",
-    "vellum_unauthenticated",
-    "unknown",
-  ]),
+  // `missing_default` is this route's own verdict (no default provider is
+  // configured at all), so it extends the shared set rather than living in it.
+  status: z.enum([...CONNECTION_AVAILABILITY_STATUSES, "missing_default"]),
   /** Present on every non-`ok` status: names the broken thing and the fix. */
   message: z.string().optional(),
 });

package/src/runtime/routes/documents-routes.ts

@@ -16,12 +16,17 @@ import {
   getDocumentById,
   getDocumentByWorkspacePath,
   getDocumentsForConversation,
+  isDocumentAssociatedWithConversation,
   refreshDocumentContentFromFile,
   saveDocument,
 } from "../../documents/document-store.js";
 import { rawAll } from "../../persistence/raw-query.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import {
+  getOriginClientId,
+  publishDocumentsChanged,
+} from "../sync/resource-sync-events.js";
 import { renderMarkdownToPDF } from "./document-pdf-renderer.js";
 import {
   BadRequestError,
@@ -159,6 +164,12 @@ function loadDocumentPayload(surfaceId: string): Record<string, unknown> {
  * content has drifted from the bytes on disk (the file was edited outside the
  * editor), the row is refreshed from the file before it is returned. Writes go
  * the other way — the document store writes through to the file.
+ *
+ * The publishes here carry no origin client id on purpose. The only caller,
+ * `viewer-store.loadWorkspaceFileDocument`, opens the file and never
+ * invalidates its own document queries, so the client that creates the row is
+ * the one that most needs to hear about it: suppressing its own echo would
+ * leave its assets pill and Library without the document it just opened.
  */
 function handleDocumentForWorkspaceFile({
   body,
@@ -194,8 +205,13 @@ function handleDocumentForWorkspaceFile({
   if (existing) {
     // Opening the file from another conversation grants that conversation
     // access, the same association the link route writes.
+    const alreadyLinked = isDocumentAssociatedWithConversation(
+      existing.surfaceId,
+      conversationId,
+    );
     addDocumentConversation(existing.surfaceId, conversationId);
 
+    let refreshed = false;
     if (existing.content !== fileText) {
       const refresh = refreshDocumentContentFromFile(
         existing.surfaceId,
@@ -204,11 +220,18 @@ function handleDocumentForWorkspaceFile({
       if (!refresh.success) {
         throw new InternalError(refresh.error);
       }
+      refreshed = true;
       log.info(
         { surfaceId: existing.surfaceId, workspacePath: relativePath },
         "Refreshed file-backed document from disk",
       );
     }
+
+    // Reopening an unchanged, already-linked file writes nothing, so it must
+    // not invalidate every client's document list on each open.
+    if (!alreadyLinked || refreshed) {
+      publishDocumentsChanged();
+    }
     return loadDocumentPayload(existing.surfaceId);
   }
 
@@ -227,7 +250,14 @@ function handleDocumentForWorkspaceFile({
     if (!raced) {
       throw new InternalError(created.error);
     }
+    const racedAlreadyLinked = isDocumentAssociatedWithConversation(
+      raced.surfaceId,
+      conversationId,
+    );
     addDocumentConversation(raced.surfaceId, conversationId);
+    if (!racedAlreadyLinked) {
+      publishDocumentsChanged();
+    }
     return loadDocumentPayload(raced.surfaceId);
   }
 
@@ -235,6 +265,7 @@ function handleDocumentForWorkspaceFile({
     { surfaceId, workspacePath: relativePath, conversationId },
     "Bound workspace file to a new document",
   );
+  publishDocumentsChanged();
   return loadDocumentPayload(surfaceId);
 }
 
@@ -325,7 +356,7 @@ export const ROUTES: RouteDefinition[] = [
       success: z.literal(true),
       surfaceId: z.string(),
     }),
-    handler: ({ body }) => {
+    handler: ({ body, headers }) => {
       const { surfaceId, conversationId, title, content, wordCount } = (body ??
         {}) as {
         surfaceId?: string;
@@ -362,6 +393,12 @@ export const ROUTES: RouteDefinition[] = [
       if (!result.success) {
         throw new InternalError(result.error);
       }
+      // Every save moves `updated_at`, which both document lists order by and
+      // the Library renders next to the word count, so a content-only save
+      // changes what the list surfaces show. The publish coalesces, which
+      // bounds the web editor's per-keystroke autosave to one broadcast per
+      // second, and the saving client suppresses its own echo by origin id.
+      publishDocumentsChanged(getOriginClientId(headers));
       return result;
     },
   },
@@ -426,6 +463,12 @@ export const ROUTES: RouteDefinition[] = [
         { surfaceId: pathParams!.id, conversationId },
         "Linked document to conversation",
       );
+      // No origin client id: the only caller, `document-viewer-page`, links the
+      // document and then navigates to the conversation whose assets pill must
+      // now list it, without invalidating anything itself. Suppressing its own
+      // echo would land it on a conversation whose pill is missing the document
+      // it just linked.
+      publishDocumentsChanged();
       return { success: true as const };
     },
   },

package/src/runtime/routes/events-routes.ts

@@ -42,7 +42,10 @@ import type { ReplaySubscriber } from "../assistant-stream-state.js";
 import { getReplayWindow } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS, GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
 import { DEFAULT_HEARTBEAT_INTERVAL_MS } from "../client-health.js";
-import { resolveActorPrincipalIdForLocalGuardianSync } from "../local-actor-identity.js";
+import {
+  resolveActorPrincipalIdForLocalGuardian,
+  resolveActorPrincipalIdForLocalGuardianSync,
+} from "../local-actor-identity.js";
 import {
   BadRequestError,
   NotFoundError,
@@ -452,6 +455,30 @@ export function handleSubscribeAssistantEvents(
     throw err;
   }
 
+  // Self-heal for dev-bypass connections: the sync resolution above reads
+  // only the guardian-delivery cache, which can be cold at connect time.
+  // Without this, the subscription would carry no principal for its whole
+  // lifetime and every host-proxy result would 403. Fire-and-forget so the
+  // stream is not delayed; keyed by connectionId so a reconnect race cannot
+  // patch the subscription that replaced this one.
+  if (
+    clientId &&
+    interfaceId &&
+    actorPrincipalId == null &&
+    rawActorPrincipalId?.trim() === "dev-bypass"
+  ) {
+    void resolveActorPrincipalIdForLocalGuardian("dev-bypass")
+      .then((resolved) => {
+        if (resolved) {
+          hub.fillClientActorPrincipalId(sub.connectionId, resolved);
+        }
+      })
+      .catch(() => {
+        // Best-effort: an unreachable gateway leaves the record unhealed;
+        // the next reconnect retries.
+      });
+  }
+
   const stream = new ReadableStream<Uint8Array>(
     {
       start(controller) {

package/src/runtime/routes/host-app-control-routes.ts

@@ -19,6 +19,7 @@ import type {
   HostAppControlResultPayload,
   HostAppControlState,
 } from "../../daemon/message-types/host-app-control.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -118,6 +119,7 @@ async function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
       targetActorPrincipalId: peeked.targetActorPrincipalId,
       targetClientId: peeked.targetClientId,
       op: "host_app_control",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 

package/src/runtime/routes/host-bash-routes.ts

@@ -7,6 +7,7 @@
 import { z } from "zod";
 
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -99,6 +100,7 @@ async function handleHostBashResult({ body, headers }: RouteHandlerArgs) {
       targetActorPrincipalId: peeked.targetActorPrincipalId,
       targetClientId,
       op: "host_bash",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 

package/src/runtime/routes/host-browser-routes.ts

@@ -11,6 +11,7 @@ import {
   publishCdpEvent,
 } from "../../browser-session/events.js";
 import { clearPinnedTabByTabId } from "../../tools/browser/pinned-tabs.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -137,6 +138,7 @@ export async function resolveHostBrowserResultByRequestId(
         targetActorPrincipalId: peeked.targetActorPrincipalId,
         targetClientId: peeked.targetClientId,
         op: "host_browser",
+        hubForMissingTarget: assistantEventHub,
       });
     } catch (err) {
       // enforceSameActorOrThrow throws ForbiddenError on rejection.

package/src/runtime/routes/host-cu-routes.ts

@@ -7,6 +7,7 @@
 import { z } from "zod";
 
 import { findConversation } from "../../daemon/conversation-registry.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -107,6 +108,7 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
       targetActorPrincipalId: peeked.targetActorPrincipalId,
       targetClientId: peeked.targetClientId,
       op: "host_cu",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 

package/src/runtime/routes/host-file-routes.ts

@@ -7,6 +7,7 @@
 import { z } from "zod";
 
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -97,6 +98,7 @@ async function handleHostFileResult({ body, headers }: RouteHandlerArgs) {
       targetActorPrincipalId: peeked.targetActorPrincipalId,
       targetClientId: peeked.targetClientId,
       op: "host_file",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 

package/src/runtime/routes/host-transfer-routes.ts

@@ -8,6 +8,7 @@
 import { z } from "zod";
 
 import { HostTransferProxy } from "../../daemon/host-transfer-proxy.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   enforceSameActorOrThrow,
@@ -83,6 +84,7 @@ async function handleTransferContentGet({
         match.proxy.getTargetActorPrincipalIdForTransfer(transferId),
       targetClientId,
       op: "host_transfer",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 
@@ -168,6 +170,7 @@ async function handleTransferContentPut({
         match.proxy.getTargetActorPrincipalIdForTransfer(transferId),
       targetClientId,
       op: "host_transfer",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 
@@ -240,6 +243,7 @@ async function handleTransferResult({ body, headers }: RouteHandlerArgs) {
       targetActorPrincipalId: peeked.targetActorPrincipalId,
       targetClientId: peeked.targetClientId,
       op: "host_transfer",
+      hubForMissingTarget: assistantEventHub,
     });
   }
 

package/src/runtime/routes/identity-routes.ts

@@ -230,15 +230,15 @@ export function handleHealth(): Response {
 }
 
 /** Disk usage for the health payload; null when it can't be measured. */
-function sampleDiskUsageInfo(): ReturnType<typeof getDiskUsageInfo> {
+async function sampleDiskUsageInfo(): ReturnType<typeof getDiskUsageInfo> {
   try {
-    return getDiskUsageInfo();
+    return await getDiskUsageInfo();
   } catch {
     return null;
   }
 }
 
-function getDetailedHealth() {
+async function getDetailedHealth() {
   let profiler: ReturnType<typeof getProfilerRuntimeStatus> | undefined;
   try {
     profiler = getProfilerRuntimeStatus();
@@ -260,7 +260,7 @@ function getDetailedHealth() {
     status: "healthy",
     timestamp: new Date().toISOString(),
     version: APP_VERSION,
-    disk: sampleDiskUsageInfo(),
+    disk: await sampleDiskUsageInfo(),
     memory: getMemoryInfo(),
     cpu: getCpuInfo(),
     migrations: {
@@ -280,8 +280,8 @@ function getDetailedHealth() {
   };
 }
 
-export function handleDetailedHealth(): Response {
-  return Response.json(getDetailedHealth());
+export async function handleDetailedHealth(): Promise<Response> {
+  return Response.json(await getDetailedHealth());
 }
 
 type UnreadyDbMigrationReadiness = Extract<

package/src/runtime/routes/inbound-message-handler.ts

@@ -1816,7 +1816,7 @@ async function persistBackfilledSlackMessage(params: {
             );
             continue;
           }
-          attachInlineAttachmentToMessage(
+          await attachInlineAttachmentToMessage(
             persisted.id,
             i,
             downloaded.filename,
@@ -1863,21 +1863,21 @@ async function persistBackfilledSlackMessage(params: {
     updateMessageContent(
       persisted.id,
       JSON.stringify(
-        buildBackfilledSlackContentBlocks(rawText, hydratedAttachments),
+        await buildBackfilledSlackContentBlocks(rawText, hydratedAttachments),
       ),
     );
   }
 }
 
-function buildBackfilledSlackContentBlocks(
+async function buildBackfilledSlackContentBlocks(
   text: string,
   attachments: MessageAttachmentInput[],
-): ContentBlock[] {
+): Promise<ContentBlock[]> {
   const blocks: ContentBlock[] = [];
   if (text.trim().length > 0) {
     blocks.push({ type: "text", text });
   }
-  blocks.push(...attachmentsToContentBlocks(attachments));
+  blocks.push(...(await attachmentsToContentBlocks(attachments)));
   return blocks;
 }
 

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -980,7 +980,12 @@ async function initiateVerificationChallenge(params: {
     try {
       [existingChallenge, existingSession] = await Promise.all([
         getPendingSession(sourceChannel),
-        findActiveSession(sourceChannel),
+        // Scoped to this sender. Reading the channel's latest and comparing
+        // its `expectedExternalUserId` misses their session whenever somebody
+        // else started more recently.
+        findActiveSession(sourceChannel, {
+          expectedExternalUserId: senderUserId,
+        }),
       ]);
     } catch (err) {
       log.warn(
@@ -992,8 +997,7 @@ async function initiateVerificationChallenge(params: {
     const senderHasPending =
       (existingChallenge &&
         existingChallenge.expectedExternalUserId === senderUserId) ||
-      (existingSession &&
-        existingSession.expectedExternalUserId === senderUserId);
+      existingSession != null;
     if (senderHasPending) {
       log.debug(
         {

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -386,6 +386,20 @@ export function processChannelMessageInBackground(
 // Telegram typing heartbeat
 // ---------------------------------------------------------------------------
 
+/**
+ * How often the typing status is re-sent while a turn runs.
+ *
+ * `sendChatAction` sets a status that expires on its own after a few seconds,
+ * and the Bot API offers no stop/start pair to hold one open, so showing
+ * typing across a multi-second turn means re-sending on a timer. The interval
+ * has to stay under that expiry or the indicator blinks off between beats;
+ * anyone changing it should check the current window first.
+ *
+ * No explicit stop is needed on the delivery path: Telegram clears the status
+ * as soon as the bot sends a message.
+ *
+ * https://core.telegram.org/bots/api#sendchataction
+ */
 const TELEGRAM_TYPING_INTERVAL_MS = 4_000;
 
 function shouldEmitTelegramTyping(

package/src/runtime/routes/inbound-stages/bootstrap-intercept.ts

@@ -26,7 +26,7 @@ import { sendTelegramReply } from "../../../messaging/providers/telegram-bot/sen
 import { getLogger } from "../../../util/logger.js";
 import { RESEND_COOLDOWN_MS } from "../../verification-outbound-actions.js";
 import {
-  composeVerificationTelegram,
+  composeVerificationText,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
 } from "../../verification-templates.js";
 
@@ -194,7 +194,7 @@ export async function handleBootstrapIntercept(
   const newSession: CreateOutboundSessionResult = minted;
 
   // Compose and send the verification prompt via Telegram
-  const telegramBody = composeVerificationTelegram(
+  const telegramBody = composeVerificationText(
     GUARDIAN_VERIFY_TEMPLATE_KEYS.TELEGRAM_CHALLENGE_REQUEST,
     {
       code: newSession.secret,

package/src/runtime/routes/inbound-stages/guardian-activation-intercept.test.ts

@@ -122,8 +122,9 @@ describe("handleGuardianActivationIntercept", () => {
       identityBindingStatus: "bound",
       destinationAddress: "chat-123",
       verificationPurpose: "guardian",
-      // No session was read: the create is a gateway-side create-if-absent.
-      ifNoneActive: true,
+      // No session was read for this sender, so the create is a
+      // sender-scoped create-if-absent.
+      ifNoneActiveForExternalUserId: "user-42",
     });
 
     // Verify deliverChannelReply was called with the welcome/verify message
@@ -243,7 +244,11 @@ describe("handleGuardianActivationIntercept", () => {
     expect(emitNotificationSignalCalls).toHaveLength(0);
   });
 
-  test("existing active session from different sender allows superseding", async () => {
+  test("someone else verifying does not turn this sender away", async () => {
+    // The read is scoped to the sender, so another person's live session is
+    // invisible here and this activation proceeds as a first one. Without the
+    // scope it would return the stranger's session and this sender would be
+    // told a verification is "already in progress" that is not theirs.
     gatewaySessions.state.activeSession = {
       id: "existing-sess",
       channel: "telegram",
@@ -254,16 +259,14 @@ describe("handleGuardianActivationIntercept", () => {
 
     const result = await handleGuardianActivationIntercept(makeParams());
 
-    // Should proceed and create a new session (superseding the stale one)
-    expect(result).not.toBeNull();
-    const body = result!;
-    expect(body).toEqual({ accepted: true, guardianActivation: true });
+    expect(result).toEqual({ accepted: true, guardianActivation: true });
     expect(gatewaySessions.calls.create).toHaveLength(1);
-    // Deliberate supersede: the create-if-absent guard is omitted so the
-    // stale session gets revoked.
+    // Carrying the guard is what keeps the stranger's code alive: the mint
+    // supersedes by bound identity, and this sender is not that identity.
     expect(
-      (gatewaySessions.calls.create[0] as Record<string, unknown>).ifNoneActive,
-    ).toBeUndefined();
+      (gatewaySessions.calls.create[0] as Record<string, unknown>)
+        .ifNoneActiveForExternalUserId,
+    ).toBe("user-42");
     expect(emitNotificationSignalCalls).toHaveLength(1);
   });
 

package/src/runtime/routes/inbound-stages/guardian-activation-intercept.ts

@@ -133,7 +133,11 @@ export async function handleGuardianActivationIntercept(
   // normal pipeline handle the message.
   let existingSession: VerificationSessionWire | null;
   try {
-    existingSession = await findActiveSession(sourceChannel);
+    // This sender's own session. The channel may carry others, and what the
+    // guard below needs to know is whether THIS activation is a duplicate.
+    existingSession = await findActiveSession(sourceChannel, {
+      expectedExternalUserId: rawSenderId,
+    });
   } catch (err) {
     log.warn(
       { err, sourceChannel },
@@ -158,25 +162,18 @@ export async function handleGuardianActivationIntercept(
     return { accepted: true, guardianActivationPending: true };
   };
 
+  // The read is scoped to this sender, so anything it returned is this
+  // sender's own activation already in flight.
   if (existingSession) {
-    // Only block if the session belongs to the same sender. If a different
-    // user triggered the session, let this sender proceed (they'll supersede
-    // the stale session via createOutboundSession's revocation logic).
-    const sessionOwner =
-      existingSession.expectedExternalUserId ?? existingSession.expectedChatId;
-    if (
-      sessionOwner === rawSenderId ||
-      sessionOwner === conversationExternalId
-    ) {
-      return respondActivationPending();
-    }
+    return respondActivationPending();
   }
 
   // ── Create verification session ──
-  // When the read above saw no active session, ifNoneActive makes the create
-  // a gateway-side create-if-absent: a concurrent activation that minted in
-  // between conflicts here instead of revoking that first code. A supersede
-  // (stale session from a different sender) deliberately omits the guard.
+  // The read above saw no session for this sender, so the sender-scoped
+  // create-if-absent makes the mint atomic: a concurrent activation from the
+  // same sender that minted in between conflicts here instead of revoking that
+  // first code. Scoped to the sender rather than the channel, because another
+  // person verifying at the same time is ordinary and must not block this.
   let sessionResult: Awaited<
     ReturnType<typeof createOutboundSessionConditional>
   >;
@@ -188,7 +185,7 @@ export async function handleGuardianActivationIntercept(
       identityBindingStatus: "bound",
       destinationAddress: conversationExternalId,
       verificationPurpose: "guardian",
-      ...(existingSession ? {} : { ifNoneActive: true }),
+      ifNoneActiveForExternalUserId: rawSenderId,
     });
   } catch (err) {
     log.warn(