@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/live-voice/protocol.ts

@@ -8,6 +8,8 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "end",
   "update_config",
   "attach_image",
+  "attach_frame",
+  "sight_frame",
   "text",
 ] as const;
 
@@ -194,18 +196,89 @@ export interface LiveVoiceClientUpdateConfigFrame {
  * caps size, and stores the blob, and routing an image through this socket
  * would duplicate all of it on a transport tuned for 50 ms audio frames.
  *
- * The id is *parked*, not dispatched. It rides the next turn's own user
- * message (see {@link LiveVoiceSession}'s pending-attachment handling), so the
- * photo and the words spoken about it are one message rather than two, which
- * is what lets "what's this?" resolve, and what keeps the image attached to the
- * newest user message, the only one a context-overflow retry preserves media on
- * (`conversation-media-retry.ts`).
+ * The id is persisted the moment it arrives, as a standalone user message that
+ * runs no turn (see `live-voice-photo.ts`). A snap the user watched themselves
+ * take has to show up in the conversation whether or not they ever speak about
+ * it, and landing it in history immediately is what makes shutter-then-speak
+ * and speak-then-shutter answer the same way.
+ *
+ * Deliberately not {@link LiveVoiceClientAttachFrameFrame}, which parks its id
+ * for the next spoken turn instead. The two frames look alike on the wire and
+ * answer opposite questions: a deliberate snap must appear now; an ambient
+ * camera frame is worthless without the words that follow it.
  */
 export interface LiveVoiceClientAttachImageFrame {
   readonly type: "attach_image";
   readonly attachmentId: string;
 }
 
+/**
+ * An ambient camera frame the client picked for the assistant to see, already
+ * uploaded over the normal attachment route, and sent here as an id alone for
+ * the same reason {@link LiveVoiceClientAttachImageFrame} sends one.
+ *
+ * The id is *parked* on the session rather than persisted. It rides the next
+ * spoken turn's own user message, and the slot is cleared as that turn starts,
+ * so a frame that arrives mid-turn belongs to the turn after it. Nothing the
+ * user asked for happened here: a frame nobody ever speaks over must leave no
+ * trace in the conversation, and a frame that does get words must be part of
+ * the same message as those words. Riding the newest user message is also what
+ * carries it through a context-overflow retry, the only message media survives
+ * on (`conversation-media-retry.ts`).
+ *
+ * Latest wins. A second frame overwrites the first, because what matters is
+ * what the camera is pointed at when the user speaks.
+ *
+ * A `null` id is the other direction: unpark, meaning the client's camera is
+ * no longer on and the slot must not keep answering for it. It clears the slot
+ * and gives the frame up, so a viewfinder the user closed leaves nothing
+ * staged behind it. Sending it needs no id of its own because the slot only
+ * ever holds one frame and only the client that parked it can be closing.
+ *
+ * `null` and a missing field are different things. An absent `attachmentId` is
+ * still a malformed frame, because a client that meant to unpark says so.
+ *
+ * Version skew: a build carrying the park half but not this one refuses the
+ * null with the attributable recoverable error, which the web client logs and
+ * drops. Only dev builds cut between the two changes are affected, and there
+ * the cost is a frame the session gives up at close instead of at unpark.
+ */
+export interface LiveVoiceClientAttachFrameFrame {
+  readonly type: "attach_frame";
+  readonly attachmentId: string | null;
+}
+
+/**
+ * An ambient camera frame the client's gate kept, already uploaded over the
+ * normal attachment route and sent here as an id alone for the same reason
+ * {@link LiveVoiceClientAttachImageFrame} sends one.
+ *
+ * Three client frames carry an image and they mean three different things:
+ *
+ * - `attach_image` is a photo the user deliberately snapped. It persists
+ *   standalone the moment it arrives and drives the client's receipt strip.
+ * - `attach_frame` parks one frame on the session for the next spoken turn's
+ *   own user message to carry, and persists nothing by itself.
+ * - `sight_frame` persists an ambient keep immediately as its own user
+ *   message, tagged as a camera frame, and runs no turn.
+ *
+ * A keep is tagged so retention can age it out of the model's context (newest
+ * few stay images, older ones become timestamped stubs) while the transcript
+ * keeps every one of them. The transcript is therefore the record of what the
+ * assistant saw, and the model correlates a frame with speech by adjacency
+ * rather than by any attachment to a turn.
+ *
+ * A frame the attachment store does not know is refused with `frameType:
+ * "sight_frame"` and `recoverable: true`: the session is fine and only this
+ * frame failed. Attributing it is what lets the client retract the preview it
+ * already showed instead of filing the error with the transient transcriber
+ * and TTS blips that share `recoverable`.
+ */
+export interface LiveVoiceClientSightFrameFrame {
+  readonly type: "sight_frame";
+  readonly attachmentId: string;
+}
+
 /**
  * A user turn the client already has as text, taken without the microphone.
  *
@@ -253,6 +326,8 @@ export type LiveVoiceClientFrame =
   | LiveVoiceClientEndFrame
   | LiveVoiceClientUpdateConfigFrame
   | LiveVoiceClientAttachImageFrame
+  | LiveVoiceClientAttachFrameFrame
+  | LiveVoiceClientSightFrameFrame
   | LiveVoiceClientTextTurnFrame;
 
 interface LiveVoiceBinaryAudioFrame {
@@ -513,11 +588,12 @@ export interface LiveVoiceErrorServerFrame extends LiveVoiceServerFrameBase {
    * daemons predating the field.
    *
    * It exists so an `unknown_type` is attributable. A client that sends more
-   * than one optional frame (today: `update_config` and `attach_image`) gets
-   * the same code for either, and without this has to assume which one was
-   * refused. The wrong assumption is silent in both directions: settings stop
-   * applying for a session, or a photo the user watched themselves take is
-   * dropped with nothing said.
+   * than one optional frame (today: `update_config`, `attach_image`,
+   * `attach_frame`, `sight_frame`, and `text`) gets the same code for any of
+   * them, and without this has to assume which one was refused. The wrong
+   * assumption is silent in both directions: settings stop applying for a
+   * session, or a photo the user watched themselves take is dropped with
+   * nothing said.
    */
   readonly frameType?: string;
   /**
@@ -654,6 +730,10 @@ export function validateLiveVoiceClientFrame(
       return validateUpdateConfigFrame(value);
     case "attach_image":
       return validateAttachImageFrame(value);
+    case "attach_frame":
+      return validateAttachFrameFrame(value);
+    case "sight_frame":
+      return validateSightFrameFrame(value);
     case "text":
       return validateTextTurnFrame(value);
   }
@@ -750,6 +830,62 @@ function validateAttachImageFrame(
   };
 }
 
+function validateAttachFrameFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientAttachFrameFrame> {
+  if (!("attachmentId" in value)) {
+    return protocolError(
+      "missing_required_field",
+      "attach_frame frame is missing required field attachmentId",
+      "attachmentId",
+      "attach_frame",
+    );
+  }
+
+  if (value.attachmentId !== null && !isNonEmptyString(value.attachmentId)) {
+    return protocolError(
+      "invalid_field",
+      "attach_frame frame field attachmentId must be a non-empty string or null",
+      "attachmentId",
+      "attach_frame",
+    );
+  }
+
+  return {
+    ok: true,
+    frame: { type: "attach_frame", attachmentId: value.attachmentId },
+  };
+}
+
+function validateSightFrameFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientSightFrameFrame> {
+  if (!("attachmentId" in value)) {
+    return protocolError(
+      "missing_required_field",
+      "sight_frame frame is missing required field attachmentId",
+      "attachmentId",
+      "sight_frame",
+    );
+  }
+
+  // No null form, unlike `attach_frame`. Nothing is staged for a keep to give
+  // up: it persisted on arrival, so a closing viewfinder has nothing to clear.
+  if (!isNonEmptyString(value.attachmentId)) {
+    return protocolError(
+      "invalid_field",
+      "sight_frame frame field attachmentId must be a non-empty string",
+      "attachmentId",
+      "sight_frame",
+    );
+  }
+
+  return {
+    ok: true,
+    frame: { type: "sight_frame", attachmentId: value.attachmentId },
+  };
+}
+
 function validateUpdateConfigFrame(
   value: Record<string, unknown>,
 ): LiveVoiceParseResult<LiveVoiceClientUpdateConfigFrame> {

package/src/messaging/provider-message-metadata.ts

@@ -61,6 +61,13 @@ export const providerMessageMetadataSchema = z
      * reaction. The message it acts on is `reaction.targetMessageId`.
      */
     messageId: z.string().optional(),
+    /**
+     * Provider ids of the further posts this row's delivery produced beyond
+     * `messageId`: one stored reply split at tool boundaries or length
+     * limits posts several provider messages, and they all belong to this
+     * one row. A reaction naming any of them resolves here.
+     */
+    additionalMessageIds: z.array(z.string()).optional(),
     /**
      * Provider id of the thread this row sits in, absent when it is not in one.
      * Never synthesized from `messageId`: a value here asserts that a thread

package/src/messaging/providers/__tests__/transport-dispatch.test.ts

@@ -8,7 +8,9 @@ const slack = {
   sendSlackReply: mock((..._args: unknown[]) =>
     Promise.resolve({ ts: "slack-ts" }),
   ),
-  sendSlackReaction: mock((..._args: unknown[]) => Promise.resolve()),
+  sendSlackReaction: mock((..._args: unknown[]) =>
+    Promise.resolve({ ok: true }),
+  ),
   sendSlackAgentSessionStatus: mock((..._args: unknown[]) => Promise.resolve()),
   sendSlackAttachments: mock((..._args: unknown[]) =>
     Promise.resolve({ allFailed: false, failureCount: 0 }),
@@ -22,6 +24,9 @@ const slack = {
 };
 const telegram = {
   editTelegramMessage: mock((..._args: unknown[]) => Promise.resolve()),
+  sendTelegramReaction: mock((..._args: unknown[]) =>
+    Promise.resolve({ ok: true }),
+  ),
   sendTelegramReply: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramRichReply: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramTypingIndicator: mock((..._args: unknown[]) => Promise.resolve()),
@@ -46,6 +51,9 @@ const discord = {
     Promise.resolve(true),
   ),
   editDiscordMessage: mock((..._args: unknown[]) => Promise.resolve()),
+  sendDiscordReaction: mock((..._args: unknown[]) =>
+    Promise.resolve({ ok: true }),
+  ),
   sendDiscordAttachments: mock((..._args: unknown[]) =>
     Promise.resolve({ allFailed: false, failureCount: 0, totalCount: 0 }),
   ),
@@ -63,9 +71,11 @@ mock.module("../../../util/logger.js", () => ({
 const {
   deliverDirect,
   editChannelMessage,
+  sendChannelReaction,
   sendChannelStreamOp,
   setChannelActivity,
   supportsChannelActivity,
+  supportsChannelReaction,
   isDirectDelivery,
   getTransportForCallback,
 } = await import("../index.js");
@@ -203,6 +213,108 @@ describe("Slack sub-operation selection", () => {
   });
 });
 
+describe("react dispatch", () => {
+  test("sendChannelReaction routes to the Slack reaction sender", async () => {
+    const result = await sendChannelReaction("slack", {
+      chatId: "C1",
+      messageId: "123.456",
+      emoji: "thumbsup",
+      action: "add",
+    });
+    expect(result.ok).toBe(true);
+    expect(slack.sendSlackReaction).toHaveBeenCalledWith(
+      "C1",
+      "thumbsup",
+      "123.456",
+      "add",
+    );
+  });
+
+  test("supportsChannelReaction follows the transport declaration", () => {
+    expect(supportsChannelReaction("slack")).toBe(true);
+    expect(supportsChannelReaction("telegram")).toBe(true);
+    expect(supportsChannelReaction("discord")).toBe(true);
+    expect(supportsChannelReaction("whatsapp")).toBe(false);
+    expect(supportsChannelReaction("some-plugin-channel")).toBe(false);
+    expect(supportsChannelReaction(undefined)).toBe(false);
+  });
+
+  test("sendChannelReaction routes to the Telegram reaction sender", async () => {
+    const result = await sendChannelReaction("telegram", {
+      chatId: "12345",
+      messageId: "678",
+      emoji: "👍",
+      action: "add",
+    });
+    expect(result.ok).toBe(true);
+    expect(telegram.sendTelegramReaction).toHaveBeenCalledWith(
+      "12345",
+      "👍",
+      "678",
+      "add",
+    );
+  });
+
+  test("a Discord thread reaction addresses the thread channel, not the parent", async () => {
+    await sendChannelReaction("discord", {
+      chatId: "PARENT",
+      threadId: "THREAD",
+      messageId: "M1",
+      emoji: "👍",
+      action: "add",
+    });
+    expect(discord.sendDiscordReaction).toHaveBeenCalledWith(
+      "THREAD",
+      "👍",
+      "M1",
+      "add",
+    );
+  });
+
+  test("Slack ignores the thread coordinate: chatId plus ts addresses the message", async () => {
+    await sendChannelReaction("slack", {
+      chatId: "C1",
+      threadId: "1716000000.000001",
+      messageId: "1716000000.000002",
+      emoji: "thumbsup",
+      action: "add",
+    });
+    expect(slack.sendSlackReaction).toHaveBeenCalledWith(
+      "C1",
+      "thumbsup",
+      "1716000000.000002",
+      "add",
+    );
+  });
+
+  test("sendChannelReaction routes to the Discord reaction sender", async () => {
+    const result = await sendChannelReaction("discord", {
+      chatId: "C9",
+      messageId: "M9",
+      emoji: "<:vex:12345>",
+      action: "remove",
+    });
+    expect(result.ok).toBe(true);
+    expect(discord.sendDiscordReaction).toHaveBeenCalledWith(
+      "C9",
+      "<:vex:12345>",
+      "M9",
+      "remove",
+    );
+  });
+
+  test("a channel without react resolves to nothing and sends nothing", async () => {
+    const result = await sendChannelReaction("whatsapp", {
+      chatId: "W1",
+      messageId: "m1",
+      emoji: "thumbsup",
+      action: "add",
+    });
+    expect(result).toEqual({ ok: true });
+    expect(whatsapp.sendWhatsAppReply).not.toHaveBeenCalled();
+  });
+});
+
 describe("capability gating across channels", () => {
   test("Slack renders a muted edit as its own context block", async () => {
     await editChannelMessage(`${BASE}/deliver/slack`, {

package/src/messaging/providers/channel-transport.ts

@@ -71,6 +71,31 @@ export interface EditTarget {
   readonly emphasis?: "muted";
 }
 
+/**
+ * The message an emoji reaction lands on, and what to do there.
+ *
+ * `emoji` is spelled in the channel's own vocabulary (a Slack emoji name, a
+ * unicode emoji elsewhere): Vellum names the operation and the channel
+ * decides what its argument means, the same way `EditTarget.text` renders
+ * per channel.
+ */
+export interface ReactionTarget {
+  readonly chatId: string;
+  /** The target message, in the channel's own id space. */
+  readonly messageId: string;
+  /**
+   * Provider id of the thread the target message sits in, absent when it is
+   * not in one. Discord needs it: `chatId` is the delivery address (a thread
+   * message's parent channel), but a thread is its own channel and the
+   * reaction route must name the channel the message actually lives in.
+   * Slack and Telegram address reactions by `chatId` + `messageId` alone
+   * and ignore it.
+   */
+  readonly threadId?: string;
+  readonly emoji: string;
+  readonly action: "add" | "remove";
+}
+
 /**
  * Direct outbound delivery for one channel, wrapping the channel's provider-API
  * send functions behind a uniform surface. Transports are registered statically
@@ -107,6 +132,18 @@ export interface ChannelTransport {
     target: EditTarget,
   ): Promise<ChannelDeliveryResult>;
 
+  /**
+   * Add or remove one of the assistant's own emoji reactions on a message.
+   *
+   * Takes no callback context: a reaction addresses its message absolutely
+   * (`chatId` + `messageId`) and carries no per-callback thread state, which
+   * is also what lets a producer with no callback URL, a tool running inside
+   * a turn, reach it. A channel whose platform has no reaction affordance
+   * omits the method, and the tool surface reads that omission as the
+   * capability's absence.
+   */
+  react?(target: ReactionTarget): Promise<ChannelDeliveryResult>;
+
   /**
    * Show how busy the assistant is, in whatever form the channel has.
    *

package/src/messaging/providers/discord/api.ts

@@ -267,9 +267,9 @@ export function resetDiscordDmChannelCache(): void {
 
 /** Call a Discord REST route with a JSON body. */
 export async function callDiscordApi<T>(
-  method: "POST" | "PATCH",
+  method: "POST" | "PATCH" | "PUT" | "DELETE",
   route: string,
-  body: Record<string, unknown>,
+  body?: Record<string, unknown>,
 ): Promise<T | undefined> {
   const botToken = await resolveBotToken();
   return discordCall<T>(route, () =>
@@ -277,10 +277,10 @@ export async function callDiscordApi<T>(
       method,
       headers: {
         Authorization: `Bot ${botToken}`,
-        "Content-Type": "application/json",
         "User-Agent": DISCORD_USER_AGENT,
+        ...(body ? { "Content-Type": "application/json" } : {}),
       },
-      body: JSON.stringify(body),
+      ...(body ? { body: JSON.stringify(body) } : {}),
       signal: AbortSignal.timeout(DISCORD_DEFAULT_TIMEOUT_MS),
     }),
   );

package/src/messaging/providers/discord/send.test.ts

@@ -30,8 +30,13 @@ mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
 }));
 
-const { sendDiscordReply, sendDiscordAttachments, editDiscordMessage } =
-  await import("./send.js");
+const {
+  sendDiscordReply,
+  sendDiscordAttachments,
+  sendDiscordReaction,
+  editDiscordMessage,
+  DiscordPartialSendError,
+} = await import("./send.js");
 
 const originalFetch = globalThis.fetch;
 
@@ -71,6 +76,40 @@ afterEach(() => {
   globalThis.fetch = originalFetch;
 });
 
+describe("sendDiscordReaction", () => {
+  test("adds via PUT on the @me reaction route, emoji URL-encoded", async () => {
+    stubFetch(204, null);
+    const result = await sendDiscordReaction("C1", "👍", "M1", "add");
+    expect(result).toEqual({ ok: true });
+    expect(calls[0].method).toBe("PUT");
+    expect(calls[0].url).toBe(
+      `https://discord.com/api/v10/channels/C1/messages/M1/reactions/${encodeURIComponent("👍")}/@me`,
+    );
+    expect(calls[0].body).toBeUndefined();
+  });
+
+  test("a custom emoji mention form travels as bare name:id", async () => {
+    stubFetch(204, null);
+    await sendDiscordReaction("C1", "<:vex:12345>", "M1", "add");
+    expect(calls[0].url).toContain(
+      `/reactions/${encodeURIComponent("vex:12345")}/@me`,
+    );
+  });
+
+  test("remove routes as DELETE", async () => {
+    stubFetch(204, null);
+    const result = await sendDiscordReaction("C1", "👍", "M1", "remove");
+    expect(result).toEqual({ ok: true });
+    expect(calls[0].method).toBe("DELETE");
+  });
+
+  test("a rejection reports ok false without throwing", async () => {
+    stubFetch(403, { message: "Missing Permissions", code: 50013 });
+    const result = await sendDiscordReaction("C1", "👍", "M1", "add");
+    expect(result).toEqual({ ok: false });
+  });
+});
+
 describe("sendDiscordReply", () => {
   test("posts to the channel's messages route with bot auth", async () => {
     await sendDiscordReply({ channelId: "C1" }, "hello");
@@ -123,6 +162,136 @@ describe("sendDiscordReply", () => {
     await sendDiscordReply({ channelId: "C1" }, "   ");
     expect(calls).toHaveLength(0);
   });
+
+  test("an approval card carries its buttons on the shared apr: convention", async () => {
+    await sendDiscordReply({ channelId: "C1" }, "Approve?", {
+      requestId: "req-1",
+      actions: [
+        { id: "approve_once", label: "Approve once" },
+        { id: "reject", label: "Reject" },
+      ],
+      plainTextFallback: "reply approve or reject",
+    });
+
+    const body = JSON.parse(calls[0].body as string);
+    expect(body.components).toEqual([
+      {
+        type: 1,
+        components: [
+          {
+            type: 2,
+            style: 1,
+            label: "Approve once",
+            custom_id: "apr:req-1:approve_once",
+          },
+          {
+            type: 2,
+            style: 4,
+            label: "Reject",
+            custom_id: "apr:req-1:reject",
+          },
+        ],
+      },
+    ]);
+  });
+
+  test("buttons ride only the final chunk of a long card", async () => {
+    const long = Array.from({ length: 400 }, (_, i) => `line ${i}`).join("\n");
+    await sendDiscordReply({ channelId: "C1" }, long, {
+      requestId: "req-1",
+      actions: [{ id: "approve_once", label: "Approve once" }],
+      plainTextFallback: "reply approve",
+    });
+
+    expect(calls.length).toBeGreaterThan(1);
+    const withComponents = calls.filter(
+      (c) => JSON.parse(c.body as string).components !== undefined,
+    );
+    // The final chunk's id is the one the delivery row records, so the
+    // message a press arrives on is the message the row can find.
+    expect(withComponents).toHaveLength(1);
+    expect(calls.indexOf(withComponents[0])).toBe(calls.length - 1);
+  });
+
+  test("an action's own emphasis outranks positional styling", async () => {
+    await sendDiscordReply({ channelId: "C1" }, "Meet?", {
+      requestId: "req-1",
+      actions: [
+        { id: "accept", label: "Accept", emphasis: "secondary" },
+        { id: "later", label: "Later" },
+      ],
+      plainTextFallback: "reply accept or later",
+    });
+
+    const row = JSON.parse(calls[0].body as string).components[0];
+    expect(row.components[0].style).toBe(2);
+    expect(row.components[1].style).toBe(2);
+  });
+
+  test("a failure after the first chunk names the undelivered remainder", async () => {
+    const long = Array.from({ length: 400 }, (_, i) => `line ${i}`).join("\n");
+    let posts = 0;
+    globalThis.fetch = (async (url: string | URL, init?: RequestInit) => {
+      posts += 1;
+      calls.push({
+        url: String(url),
+        method: init?.method ?? "GET",
+        headers: {},
+        body: init?.body,
+      });
+      if (posts > 1) {
+        return new Response(JSON.stringify({ message: "rejected" }), {
+          status: 400,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      return new Response(JSON.stringify({ id: "msg-1" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    let thrown: unknown;
+    try {
+      await sendDiscordReply({ channelId: "C1" }, long);
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(DiscordPartialSendError);
+    const partial = thrown as InstanceType<typeof DiscordPartialSendError>;
+    expect(partial.chunksSent).toBe(1);
+    expect(partial.lastMessageId).toBe("msg-1");
+    // The delivered prefix plus the named remainder reassemble the text, so
+    // a caller completing the card sends no line twice and drops none.
+    const delivered = JSON.parse(calls[0].body as string).content;
+    expect(`${delivered}\n${partial.remainingText}`).toBe(long);
+  });
+
+  test("a failure on the first chunk propagates plainly, so full fallback is safe", async () => {
+    stubFetch(400, { message: "rejected" });
+
+    let thrown: unknown;
+    try {
+      await sendDiscordReply({ channelId: "C1" }, "short card");
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(Error);
+    expect(thrown).not.toBeInstanceOf(DiscordPartialSendError);
+  });
+
+  test("a custom_id past Discord's cap throws instead of sending a dead button", async () => {
+    await expect(
+      sendDiscordReply({ channelId: "C1" }, "Approve?", {
+        requestId: "r".repeat(120),
+        actions: [{ id: "approve_once", label: "Approve once" }],
+        plainTextFallback: "reply approve",
+      }),
+    ).rejects.toThrow("100-character limit");
+    expect(calls).toHaveLength(0);
+  });
 });
 
 describe("sendDiscordAttachments", () => {
@@ -183,6 +352,12 @@ describe("editDiscordMessage", () => {
   const bodyOf = (index = 0): Record<string, unknown> =>
     JSON.parse(String(calls[index]?.body)) as Record<string, unknown>;
 
+  test("an edit always strips components, so a settled card keeps no live buttons", async () => {
+    await editDiscordMessage({ channelId: "C1" }, "m1", "Approved");
+    const body = JSON.parse(calls[0].body as string);
+    expect(body.components).toEqual([]);
+  });
+
   test("patches the message rather than posting a new one", async () => {
     await editDiscordMessage({ channelId: "C1" }, "M9", "revised");