@vellumai/assistant 0.11.8 → 0.11.9-staging.1

package/src/notifications/access-request-copy.ts

@@ -20,7 +20,10 @@ import {
   nonEmpty,
   sanitizeIdentityField,
   sanitizeMessagePreview,
+  stripReplyMechanicsFromCopy,
+  stripRequestCodeDirectives,
 } from "./notification-utils.js";
+import type { RenderedChannelCopy } from "./types.js";
 
 // ── Zod schema for access-request payloads ──────────────────────────────────
 
@@ -150,7 +153,7 @@ export function isHandshakeOfferedForPayload(
 }
 
 /** Internal typed implementation — avoids re-parsing when called from
- *  buildAccessRequestContractText which has already parsed the payload. */
+ *  buildAccessRequestContextText which has already parsed the payload. */
 function buildIdentityLineFromParsed(p: ParsedAccessRequestPayload): string {
   const requester = sanitizeIdentityField(p.senderIdentifier || "Someone");
   const callerName = nonEmpty(p.actorDisplayName);
@@ -235,112 +238,25 @@ export function buildAccessRequestInviteDirective(): string {
 }
 
 /**
- * Normalize text before running directive-matching regexes.
+ * Guardian-facing context for an access request: who is asking, what they
+ * said, any warnings, where it came from, and the invite-flow directive.
+ * The invite directive is context rather than mechanics because no surface
+ * offers a button for it: typing "open invite flow" is the only way to start
+ * it anywhere, so every surface has to say so. The request-code directive
+ * is {@link buildAccessRequestReplyMechanics}, and only the broadcaster's
+ * `plainTextFallback` holds it, so a transport appends it exactly when it
+ * sends text without buttons.
  *
- * - Replaces smart/curly apostrophes (\u2018, \u2019, \u201B) with ASCII `'`
- *   so contractions like "Don\u2019t" are matched by the `n't` lookbehind.
- * - Collapses runs of whitespace into a single space so "Do not   reply"
- *   is matched by the single-space negative lookbehind.
- * - Trims leading/trailing whitespace.
+ * Channel-agnostic by design: this reads the generic `contextPayload` and
+ * renders the same on every channel. When `guardianResolutionSource` is
+ * present and not `"source-channel-contact"`, the guardian was resolved via
+ * fallback (e.g. vellum anchor) rather than a verified same-channel contact,
+ * and the copy says so.
  */
-export function normalizeForDirectiveMatching(text: string): string {
-  return text
-    .replace(/[\u2018\u2019\u201B]/g, "'")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-/** Build a negated-lookbehind directive regex for `reply ... "CODE <verb>"`. */
-function buildCodeDirectiveRegex(escapedCode: string, verb: string): RegExp {
-  return new RegExp(
-    `(?<!not\\s)(?<!n't\\s)(?<!never\\s)reply\\b[^.!?\\n]*?"${escapedCode}\\s+${verb}"`,
-    "i",
-  );
-}
-
-/**
- * Check whether a text contains the required access-request instruction
- * elements for the introduction card:
- * 1. Trust directive: Reply "CODE trust"
- * 2. Verify directive: Reply "CODE verify" — only when the handshake is
- *    offered for this requester (never for bots / workspace-vouched members)
- * 3. Leave-unverified directive: Reply "CODE reject"
- * 4. Block directive: Reply "CODE block"
- * 5. Invite directive: Reply "open invite flow"
- *
- * Each directive is matched independently using negative lookbehind to reject
- * matches preceded by negation words ("not", "n't", "never"). This prevents
- * contradictory copy like `Do not reply "CODE reject"` from satisfying the
- * check even when a positive directive exists nearby.
- *
- * The text is normalized before matching to handle smart apostrophes and
- * multiple whitespace characters that would otherwise bypass negation detection.
- */
-export function hasAccessRequestInstructions(
-  text: string | undefined,
-  requestCode: string,
-  options?: { handshakeOffered?: boolean },
-): boolean {
-  if (typeof text !== "string") {
-    return false;
-  }
-  const handshakeOffered = options?.handshakeOffered ?? true;
-  const normalized = normalizeForDirectiveMatching(text);
-  const escapedCode = requestCode.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  // Each directive must follow "reply" without a preceding negation word.
-  // Negative lookbehinds reject "do not reply", "don't reply", "never reply".
-  const trustRe = buildCodeDirectiveRegex(escapedCode, "trust");
-  const verifyRe = buildCodeDirectiveRegex(escapedCode, "verify");
-  const rejectRe = buildCodeDirectiveRegex(escapedCode, "reject");
-  const blockRe = buildCodeDirectiveRegex(escapedCode, "block");
-  const inviteRe =
-    /(?<!not\s)(?<!n't\s)(?<!never\s)reply\b[^.!?\n]*?"open invite flow"/i;
-
-  return (
-    trustRe.test(normalized) &&
-    (!handshakeOffered || verifyRe.test(normalized)) &&
-    rejectRe.test(normalized) &&
-    blockRe.test(normalized) &&
-    inviteRe.test(normalized)
-  );
-}
-
-/**
- * Check whether text contains the invite-flow directive ("open invite flow")
- * using the same normalized negative-lookbehind pattern as the full check.
- * This is used for enforcement when requestCode is absent but the invite
- * directive should still be present.
- */
-export function hasInviteFlowDirective(text: string | undefined): boolean {
-  if (typeof text !== "string") {
-    return false;
-  }
-  const normalized = normalizeForDirectiveMatching(text);
-  const inviteRe =
-    /(?<!not\s)(?<!n't\s)(?<!never\s)reply\b[^.!?\n]*?"open invite flow"/i;
-  return inviteRe.test(normalized);
-}
-
-// ── Contract text builder ───────────────────────────────────────────────────
-
-/**
- * Build the deterministic access-request contract text from payload fields.
- * This is the canonical baseline that enforcement can append when generated
- * copy is missing required elements.
- *
- * Channel-agnostic by design: this function reads from the generic
- * `contextPayload` and works identically regardless of which channel
- * (Slack, Telegram, desktop, etc.) the notification is delivered to.
- * When `guardianResolutionSource` is present and not `"source-channel-contact"`,
- * the guardian was resolved via fallback (e.g. vellum anchor) rather than
- * a verified same-channel contact — downstream copy or routing can use
- * this to append verification CTAs like "Was this you?".
- */
-export function buildAccessRequestContractText(
+export function buildAccessRequestContextText(
   payload: Record<string, unknown>,
 ): string {
   const p = parseAccessRequestPayload(payload);
-  const requestCode = nonEmpty(p.requestCode);
 
   const lines: string[] = [];
   lines.push(buildIdentityLineFromParsed(p));
@@ -371,18 +287,6 @@ export function buildAccessRequestContractText(
     lines.push(source);
   }
 
-  if (requestCode) {
-    const code = requestCode.toUpperCase();
-    if (isHandshakeOfferedForPayload(p)) {
-      lines.push(
-        `Reply "${code} verify" to send them a verification code, "${code} trust" to trust them without one, "${code} reject" to leave them unverified, or "${code} block" to block them.`,
-      );
-    } else {
-      lines.push(
-        `Reply "${code} trust" to trust them, "${code} reject" to leave them unverified, or "${code} block" to block them.`,
-      );
-    }
-  }
   lines.push(buildAccessRequestInviteDirective());
 
   if (
@@ -397,6 +301,114 @@ export function buildAccessRequestContractText(
   return lines.join("\n");
 }
 
+/**
+ * The typed-reply mechanics for an access request: the request-code
+ * directive (verify, trust, reject, block; or trust, reject, block when no
+ * handshake is offered). This is the broadcaster's `plainTextFallback` for
+ * the card, appended to a message only by a transport that sends text
+ * without buttons. Empty when the request carries no code, since there is
+ * then nothing to type.
+ */
+export function buildAccessRequestReplyMechanics(
+  payload: Record<string, unknown>,
+): string {
+  const p = parseAccessRequestPayload(payload);
+  const requestCode = nonEmpty(p.requestCode);
+  if (!requestCode) {
+    return "";
+  }
+  const code = requestCode.toUpperCase();
+  return isHandshakeOfferedForPayload(p)
+    ? `Reply "${code} verify" to send them a verification code, "${code} trust" to trust them without one, "${code} reject" to leave them unverified, or "${code} block" to block them.`
+    : `Reply "${code} trust" to trust them, "${code} reject" to leave them unverified, or "${code} block" to block them.`;
+}
+
+/**
+ * Remove request-code reply mechanics the model wrote into composed copy
+ * ({@link stripRequestCodeDirectives}). The invite-flow directive is context
+ * and stays.
+ */
+export function stripAccessRequestReplyMechanics(
+  text: string,
+  payload: Record<string, unknown>,
+): string {
+  const requestCode = nonEmpty(parseAccessRequestPayload(payload).requestCode);
+  return requestCode ? stripRequestCodeDirectives(text, requestCode) : text;
+}
+
+/**
+ * The text-only rendering of an access request: the context, then the
+ * typed directive when the request carries a code. This is the card's text
+ * sibling, what a client without buttons (the CLI, search, the model) sees
+ * in place of the card.
+ */
+export function buildAccessRequestTextFallback(
+  payload: Record<string, unknown>,
+): string {
+  const mechanics = buildAccessRequestReplyMechanics(payload);
+  const context = buildAccessRequestContextText(payload);
+  return mechanics ? `${context}\n${mechanics}` : context;
+}
+
+/**
+ * Whether text carries a positive invite-flow directive: a "reply ..."
+ * sentence naming the phrase, not preceded by a negation. A bare mention
+ * ("the open invite flow is disabled") or a negated form ("do not reply
+ * ...") does not count, so the canonical directive still gets appended.
+ */
+export function hasInviteFlowDirective(text: string): boolean {
+  const normalized = text
+    .replace(/[\u2018\u2019\u201B]/g, "'")
+    .replace(/\s+/g, " ");
+  return /(?<!not )(?<!n't )(?<!never )reply\b[^.!?\n]*?"open invite flow"/i.test(
+    normalized,
+  );
+}
+
+/**
+ * Ensure the invite-flow directive is in every text field of a channel's
+ * access-request copy. It is context rather than mechanics (no surface has
+ * an invite button, so the sentence is the only way to start the flow), and
+ * model-composed copy can omit, negate, or merely mention it, so the
+ * canonical sentence is appended whenever no positive directive is present.
+ * A title stays a title.
+ */
+export function ensureAccessRequestInviteDirectiveInCopy(
+  copy: RenderedChannelCopy,
+): RenderedChannelCopy {
+  const ensure = (text: string): string =>
+    hasInviteFlowDirective(text)
+      ? text
+      : `${text.trim()}\n${buildAccessRequestInviteDirective()}`;
+  return {
+    ...copy,
+    body: ensure(copy.body),
+    deliveryText: copy.deliveryText
+      ? ensure(copy.deliveryText)
+      : copy.deliveryText,
+    conversationSeedMessage: copy.conversationSeedMessage
+      ? ensure(copy.conversationSeedMessage)
+      : copy.conversationSeedMessage,
+  };
+}
+
+/**
+ * {@link stripAccessRequestReplyMechanics} over every text field of a
+ * channel's copy; a field left empty becomes the requester context.
+ */
+export function stripAccessRequestReplyMechanicsFromCopy(
+  copy: RenderedChannelCopy,
+  payload: Record<string, unknown>,
+): RenderedChannelCopy {
+  const requestCode = nonEmpty(parseAccessRequestPayload(payload).requestCode);
+  return stripReplyMechanicsFromCopy(
+    copy,
+    (text) =>
+      requestCode ? stripRequestCodeDirectives(text, requestCode) : text,
+    buildAccessRequestContextText(payload),
+  );
+}
+
 // ── Card view model ─────────────────────────────────────────────────────────
 
 /**

package/src/notifications/adapters/discord.ts

@@ -31,7 +31,11 @@ import type {
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
-import { appendPlainTextFallback, resolveMessageText } from "./shared.js";
+import {
+  appendPlainTextFallback,
+  rendersActions,
+  resolveMessageText,
+} from "./shared.js";
 
 const log = getLogger("notif-adapter-discord");
 
@@ -60,7 +64,7 @@ export class DiscordAdapter implements ChannelAdapter {
     try {
       const channelId = await openDiscordDmChannel(guardianUserId);
 
-      if (approval) {
+      if (rendersActions(approval)) {
         // Attempt rich delivery with component buttons; on failure, fall
         // back to the plain-text card below.
         try {
@@ -74,7 +78,7 @@ export class DiscordAdapter implements ChannelAdapter {
             "Discord approval notification delivered with buttons",
           );
           // The message id lets the delivery row address the card later
-          // (reactions, button presses, in-place withdrawal).
+          // (button presses, in-place withdrawal).
           return { success: true, messageId: sent.lastMessageId };
         } catch (richErr) {
           if (richErr instanceof DiscordPartialSendError) {
@@ -108,8 +112,8 @@ export class DiscordAdapter implements ChannelAdapter {
         }
       }
 
-      // When falling back from rich delivery, append the plain-text
-      // instructions so the guardian still knows how to approve/reject.
+      // Text without buttons carries the typed-reply instructions, whether
+      // the rich delivery failed or the request never had buttons to draw.
       const sent = await sendDiscordReply(
         { channelId },
         appendPlainTextFallback(messageText, approval),

package/src/notifications/adapters/shared.ts

@@ -35,10 +35,23 @@ export function resolveMessageText(payload: ChannelDeliveryPayload): string {
 }
 
 /**
- * Append an approval's typed-command instructions to the message text, when
- * the copy does not already carry them. Used by adapters delivering an
- * approval without live buttons (Discord always; Telegram when its rich
- * delivery fails), so the guardian still knows how to decide.
+ * Whether an approval context has buttons to draw. A context with no actions
+ * (an option-less question) is answered by typed reply, so it takes the
+ * plain-text path with {@link appendPlainTextFallback} rather than a card
+ * with nothing on it.
+ */
+export function rendersActions(
+  approval: ChannelDeliveryPayload["approvalContext"],
+): approval is NonNullable<ChannelDeliveryPayload["approvalContext"]> {
+  return approval != null && approval.actions.length > 0;
+}
+
+/**
+ * Append an approval's typed-reply instructions to the message text, when
+ * the text does not already carry them. This is the only place reply
+ * mechanics join a message: composed copy never carries them, so an adapter
+ * sending text without live buttons (no actions to draw, or a rich delivery
+ * that failed) appends them here and the guardian still knows how to answer.
  */
 export function appendPlainTextFallback(
   text: string,

package/src/notifications/adapters/slack.ts

@@ -39,7 +39,11 @@ import type {
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
-import { resolveMessageText } from "./shared.js";
+import {
+  appendPlainTextFallback,
+  rendersActions,
+  resolveMessageText,
+} from "./shared.js";
 
 const log = getLogger("notif-adapter-slack");
 
@@ -444,13 +448,19 @@ export class SlackAdapter implements ChannelAdapter {
       // `approval` rides along with the prebuilt card blocks so the send
       // layer treats a rejected Block Kit payload as an approval prompt:
       // its block-free retry re-attaches `plainTextFallback` reply
-      // instructions instead of posting text with no way to respond.
-      const result = payload.approvalContext
+      // instructions instead of posting text with no way to respond. A
+      // context with no buttons to draw is answered by typed reply, so its
+      // instructions join the text up front.
+      const result = rendersActions(payload.approvalContext)
         ? await sendSlackReply(chatId, messageText, {
             blocks: buildApprovalNotificationBlocks(payload, messageText),
             approval: payload.approvalContext,
           })
-        : await sendSlackReply(chatId, messageText, { useBlocks: true });
+        : await sendSlackReply(
+            chatId,
+            appendPlainTextFallback(messageText, payload.approvalContext),
+            { useBlocks: true },
+          );
 
       log.info(
         { sourceEventName: payload.sourceEventName, chatId, ts: result.ts },

package/src/notifications/adapters/telegram.ts

@@ -23,7 +23,11 @@ import type {
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
-import { appendPlainTextFallback, resolveMessageText } from "./shared.js";
+import {
+  appendPlainTextFallback,
+  rendersActions,
+  resolveMessageText,
+} from "./shared.js";
 
 const log = getLogger("notif-adapter-telegram");
 
@@ -50,7 +54,7 @@ export class TelegramAdapter implements ChannelAdapter {
     const approval = payload.approvalContext;
 
     try {
-      if (approval) {
+      if (rendersActions(approval)) {
         // Attempt rich delivery with inline keyboard buttons.
         // On failure, fall back to plain text below.
         try {
@@ -72,8 +76,8 @@ export class TelegramAdapter implements ChannelAdapter {
         }
       }
 
-      // When falling back from rich delivery, append the plain-text
-      // instructions so the guardian still knows how to approve/reject.
+      // Text without buttons carries the typed-reply instructions, whether
+      // the rich delivery failed or the request never had buttons to draw.
       const sent = await sendTelegramReply(
         chatId,
         appendPlainTextFallback(messageText, approval),

package/src/notifications/approval-card-data.ts

@@ -17,7 +17,7 @@ import {
   accessRequestCardSubtitle,
   accessRequestCardTitle,
   buildAccessRequestCardView,
-  buildAccessRequestContractText,
+  buildAccessRequestTextFallback,
   buildIntroductionActionsForPayload,
   parseAccessRequestPayload,
 } from "./access-request-copy.js";
@@ -238,7 +238,10 @@ function resolveAccessRequestCard(
     metadata,
     requestId: view.requestId,
     actions,
-    fallbackText: buildAccessRequestContractText(payload),
+    // The card's text sibling is what a client without buttons sees (the
+    // CLI, search, the model), so it is the one place the card itself
+    // carries the typed directive beside the context.
+    fallbackText: buildAccessRequestTextFallback(payload),
   };
 }
 

package/src/notifications/assistant-reply-producer.ts

@@ -36,6 +36,7 @@ import {
   describeMedia,
   mediaEmbeds,
   sanitizeMessagePreview,
+  sanitizeMultilineMessagePreview,
   sanitizeNotificationTitle,
   stripMarkdownForPreview,
 } from "./notification-utils.js";
@@ -50,10 +51,10 @@ const DESKTOP_PRESENCE_FLAG = "desktop-presence-suppression" as const;
 const WEB_PRESENCE_FLAG = "web-presence-suppression" as const;
 
 /**
- * Collapse whitespace runs ahead of the sanitizers' truncation: blank lines and
- * list indentation would otherwise eat into the copy's length budget.
+ * Flatten a title onto one line. Notification titles cannot wrap, and
+ * `normalizeTitle` discards any string that still contains a newline.
  */
-function collapseWhitespace(value: string): string {
+function flattenTitleWhitespace(value: string): string {
   return value.replace(/\s+/g, " ").trim();
 }
 
@@ -229,9 +230,8 @@ export async function emitAssistantReplyNotification(params: {
     // text nor media stays silent.
     const text = stringifyMessageContent(assistantRow.content);
     const preview =
-      sanitizeMessagePreview(
-        collapseWhitespace(stripMarkdownForPreview(text)),
-      ) || sanitizeMessagePreview(describeReplyMedia(text, assistantMessageId));
+      sanitizeMultilineMessagePreview(stripMarkdownForPreview(text)) ||
+      sanitizeMessagePreview(describeReplyMedia(text, assistantMessageId));
     if (!preview) {
       return;
     }
@@ -242,7 +242,7 @@ export async function emitAssistantReplyNotification(params: {
     // title from the body, which reads better than an empty or placeholder
     // conversation title.
     const requestedTitle = sanitizeNotificationTitle(
-      collapseWhitespace(conversation.title ?? ""),
+      flattenTitleWhitespace(conversation.title ?? ""),
     );
 
     // Read as close to the emit as possible: nothing short-circuits on it.

package/src/notifications/broadcaster.ts

@@ -16,7 +16,7 @@ import { getConversation } from "../persistence/conversation-crud.js";
 import type { ApprovalUIMetadata } from "../runtime/channel-approval-types.js";
 import { getLogger } from "../util/logger.js";
 import {
-  buildAccessRequestContractText,
+  buildAccessRequestReplyMechanics,
   buildIntroductionActionsForPayload,
   parseAccessRequestPayload,
 } from "./access-request-copy.js";
@@ -33,14 +33,16 @@ import {
 } from "./deliveries-store.js";
 import { resolveDestinations } from "./destination-resolver.js";
 import {
+  buildGuardianRequestCodeInstruction,
   buildQuestionAnswerActions,
   buildToolApprovalSourceView,
   parseGuardianQuestionPayload,
   parseInteractiveApprovalPayload,
   resolveGuardianInstructionModeFromPayload,
+  resolveGuardianQuestionInstructionMode,
   type ToolApprovalSourceView,
 } from "./guardian-question-mode.js";
-import { nonEmpty } from "./notification-utils.js";
+import { nonEmpty, readPayloadString } from "./notification-utils.js";
 import type { NotificationSignal } from "./signal.js";
 import type {
   ChannelAdapter,
@@ -97,25 +99,25 @@ function resolveApprovalContext(
         actions: buildIntroductionActionsForPayload(
           parseAccessRequestPayload(payload),
         ),
-        plainTextFallback: buildAccessRequestContractText(payload),
+        plainTextFallback: buildAccessRequestReplyMechanics(payload),
       },
     };
   }
 
   if (signal.sourceEventName === "guardian.question") {
-    // Answer-mode question with structured options (an ask_question prompt):
-    // render the options as card actions so every channel adapter shows
-    // tappable choices. Built here — once per broadcast — so adapters stay
-    // rendering-only; the reply router recognizes the action ids as answer
-    // selections (see parseQuestionAnswerActionId).
-    const questionContext = resolveQuestionOptionsContext(payload);
+    // Answer-mode question: options render as card actions so every channel
+    // adapter shows tappable choices, and an option-less question carries
+    // its typed-reply instruction. Built here, once per broadcast, so
+    // adapters stay rendering-only; the reply router recognizes the action
+    // ids as answer selections (see parseQuestionAnswerActionId).
+    const questionContext = resolveQuestionContext(payload);
     if (questionContext) {
       return questionContext;
     }
 
     const parsed = parseInteractiveApprovalPayload(payload);
     if (!parsed) {
-      return undefined;
+      return resolveCodedTextContext(payload);
     }
     const requestId = parsed.requestId;
 
@@ -139,7 +141,10 @@ function resolveApprovalContext(
       approval: {
         requestId,
         actions: APPROVAL_ACTIONS,
-        plainTextFallback: `Reply "${parsed.requestCode?.toUpperCase() ?? requestId} approve" or "${parsed.requestCode?.toUpperCase() ?? requestId} reject"`,
+        plainTextFallback: buildGuardianRequestCodeInstruction(
+          parsed.requestCode?.toUpperCase() ?? requestId,
+          "approval",
+        ),
         permissionDetails: toolName
           ? {
               toolName,
@@ -157,14 +162,43 @@ function resolveApprovalContext(
 }
 
 /**
- * Card actions for an answer-mode `pending_question` payload carrying
- * structured options: one action per option plus Skip, ids in the
- * answer-selection scheme. Returns `undefined` for approval-mode payloads,
- * option-less questions (voice questions answer by free text), and anything
- * that fails strict parsing — those fall through to the approval/plain-text
- * paths.
+ * A `guardian.question` payload that fails strict parsing draws no buttons
+ * anywhere, so its only way to be answered is the typed reply. When it
+ * still names a request id and code, it gets a context with no actions and
+ * the instruction for its mode, which the transports render as text plus
+ * the instruction. Without those it is undefined, as before.
  */
-function resolveQuestionOptionsContext(
+function resolveCodedTextContext(
+  payload: Record<string, unknown>,
+): ResolvedApprovalContext | undefined {
+  const requestId = nonEmpty(readPayloadString(payload, "requestId"));
+  const requestCode = nonEmpty(readPayloadString(payload, "requestCode"));
+  if (!requestId || !requestCode) {
+    return undefined;
+  }
+  return {
+    approval: {
+      requestId,
+      actions: [],
+      plainTextFallback: buildGuardianRequestCodeInstruction(
+        requestCode.toUpperCase(),
+        resolveGuardianQuestionInstructionMode(payload).mode,
+      ),
+    },
+  };
+}
+
+/**
+ * The card context for an answer-mode `pending_question`: one action per
+ * option plus Skip, ids in the answer-selection scheme, and the typed-reply
+ * instruction as the text fallback. An option-less question (a voice
+ * question, answered by free text) carries no actions, only the fallback:
+ * the transports read an empty action set as "send text, append the
+ * instruction", which is the one way that question stays answerable.
+ * Returns `undefined` for approval-mode payloads and anything that fails
+ * strict parsing; those fall through to the approval path.
+ */
+function resolveQuestionContext(
   payload: Record<string, unknown>,
 ): ResolvedApprovalContext | undefined {
   const parsed = parseGuardianQuestionPayload(payload);
@@ -174,21 +208,19 @@ function resolveQuestionOptionsContext(
   if (resolveGuardianInstructionModeFromPayload(parsed).mode !== "answer") {
     return undefined;
   }
-  const options = parsed.options;
-  if (!options || options.length === 0) {
-    return undefined;
-  }
   const requestId = nonEmpty(parsed.requestId);
   if (!requestId) {
     return undefined;
   }
 
-  const code = parsed.requestCode?.toUpperCase() ?? requestId;
   return {
     approval: {
       requestId,
-      actions: buildQuestionAnswerActions(options),
-      plainTextFallback: `Reply "${code} <your answer>".`,
+      actions: buildQuestionAnswerActions(parsed.options ?? []),
+      plainTextFallback: buildGuardianRequestCodeInstruction(
+        parsed.requestCode?.toUpperCase() ?? requestId,
+        "answer",
+      ),
       intent: "question",
     },
   };