@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/live-voice/live-voice-session.ts

@@ -112,8 +112,8 @@ import {
   type VoiceEndpointSource,
 } from "./live-voice-metrics.js";
 import {
+  persistAmbientSightFrame,
   persistLiveVoicePhoto,
-  persistLiveVoiceSightFrame,
 } from "./live-voice-photo.js";
 import {
   type LiveVoiceSession as LiveVoiceSessionContract,
@@ -1694,9 +1694,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * same fact.
    */
   private persistSightFrame(frame: LiveVoiceClientSightFrameFrame): void {
-    void persistLiveVoiceSightFrame(
+    void persistAmbientSightFrame(
       this.conversationId,
       frame.attachmentId,
+      "voice",
     ).then((result) => {
       if (!result.ok && !this.isClosed) {
         void this.sendFrame({
@@ -1707,6 +1708,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           // preview it already showed, rather than filing this with the
           // transient transcriber and TTS blips that share `recoverable`.
           frameType: "sight_frame",
+          // Which keep, not just which stream: several can be outstanding
+          // while a persist waits out a turn.
+          attachmentId: frame.attachmentId,
           // The session is fine; only this frame failed.
           recoverable: true,
         });

package/src/live-voice/protocol.ts

@@ -272,7 +272,9 @@ export interface LiveVoiceClientAttachFrameFrame {
  * "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`.
+ * and TTS blips that share `recoverable`. The refusal echoes the frame's
+ * `attachmentId` too, because keeps overlap: see that field on
+ * {@link LiveVoiceErrorServerFrame}.
  */
 export interface LiveVoiceClientSightFrameFrame {
   readonly type: "sight_frame";
@@ -602,6 +604,23 @@ export interface LiveVoiceErrorServerFrame extends LiveVoiceServerFrameBase {
    * from older daemons) means the error is terminal for the session.
    */
   readonly recoverable?: boolean;
+  /**
+   * The attachment the refused frame named, present on `sight_frame`
+   * rejections so the client can retire the exact keep that failed.
+   *
+   * `frameType` alone only narrows a rejection to the keep stream, and that
+   * stream is the one place several sends are routinely outstanding at once:
+   * the camera keeps shooting while a persist waits out a running turn, so a
+   * client holding three unacknowledged keeps cannot tell which of them this
+   * error is about. Naming the id is what turns "a frame failed" into "this
+   * preview comes down".
+   *
+   * Optional, and no other error path populates it: a parse failure has no
+   * id to name, and the other frames carrying an attachment have at most one
+   * in flight, which `frameType` already identifies. Clients must tolerate
+   * an absent id and must not gate any behavior on its presence.
+   */
+  readonly attachmentId?: string;
 }
 
 export type LiveVoiceServerFrame =

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

@@ -1,3 +1,4 @@
+import { ReactionEmojiFieldsSchema } from "@vellumai/service-contracts/reactions";
 import { z } from "zod";
 
 import { CHANNEL_IDS } from "../channels/types.js";
@@ -40,7 +41,21 @@ const providerReactionMetadataSchema = z.object({
    * namespace as `messageId`. Resolution is keyed on it, so it is required.
    */
   targetMessageId: z.string(),
+  /**
+   * The emoji in the channel's own spelling. Kept because the channel's
+   * write path consumes it and the model hands it back verbatim; the typed
+   * fields beside it are what a reader consults.
+   */
   emoji: z.string(),
+  /**
+   * Which namespace the emoji was drawn from, as the channel said it. Spread
+   * from the shared group rather than restated, and declared rather than
+   * left to passthrough: the outer envelope passes unknown keys through, but
+   * this nested object strips them, so an undeclared field writes fine and
+   * reads back as nothing with no error at either end. A row carrying only
+   * the spelling has its kind recovered by `resolveInboundReactionPayload`.
+   */
+  ...ReactionEmojiFieldsSchema.shape,
   op: z.enum(["added", "removed"]),
   actorDisplayName: z.string().optional(),
 });
@@ -65,7 +80,7 @@ export const providerMessageMetadataSchema = z
      * 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.
+     * one row. A reaction or delete naming any of them resolves here.
      */
     additionalMessageIds: z.array(z.string()).optional(),
     /**
@@ -89,7 +104,19 @@ export const providerMessageMetadataSchema = z
     eventKind: z.enum(["message", "reaction"]),
     reaction: providerReactionMetadataSchema.optional(),
     editedAt: z.number().optional(),
+    /**
+     * The row is no longer visible on the channel: every provider post it
+     * produced has been deleted. Readers treat this as the whole row's
+     * deletion mark, as before rows could name several posts.
+     */
     deletedAt: z.number().optional(),
+    /**
+     * Provider ids among `messageId`/`additionalMessageIds` whose posts have
+     * been deleted on the channel. A split reply can lose one post while the
+     * others stay visible, so deletion is tracked per id; `deletedAt` is
+     * stamped only once every id is here.
+     */
+    deletedMessageIds: z.array(z.string()).optional(),
   })
   .passthrough();
 
@@ -100,6 +127,18 @@ export type ProviderMessageMetadata = z.infer<
   typeof providerMessageMetadataSchema
 >;
 
+/**
+ * Whether every post a row names is among its deleted ones, which is exactly
+ * when the row-level `deletedAt` is warranted. A row naming no post is a
+ * single post by construction, so an empty list reads as fully deleted.
+ */
+export function everyPostDeleted(
+  postIds: readonly string[],
+  deletedIds: readonly string[] | undefined,
+): boolean {
+  return postIds.every((id) => deletedIds?.includes(id) === true);
+}
+
 /**
  * Parse and validate a serialized `ProviderMessageMetadata`, the counterpart of
  * `readSlackMetadata` for the neutral shape. Anything that does not parse or

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

@@ -23,6 +23,10 @@ const slack = {
   ),
 };
 const telegram = {
+  // Spread the real module so a stub listing only what today's tests touch
+  // cannot break the next import a transport adds; the mocks below then
+  // override exactly the calls this suite asserts on.
+  ...(await import("../telegram-bot/send.js")),
   editTelegramMessage: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramReaction: mock((..._args: unknown[]) =>
     Promise.resolve({ ok: true }),
@@ -90,8 +94,12 @@ function payload(
 
 beforeEach(() => {
   for (const group of [slack, telegram, whatsapp, a2a, discord]) {
-    for (const spy of Object.values(group)) {
-      spy.mockClear();
+    for (const value of Object.values(group)) {
+      // A group spreads its real module so a stub cannot fall behind the
+      // exports a transport imports, which means it also carries constants
+      // and untouched functions. Only the spies have anything to clear.
+      const spy = value as { mockClear?: () => void };
+      spy.mockClear?.();
     }
   }
 });

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

@@ -189,4 +189,32 @@ export interface ChannelTransport {
     chatId: string,
     op: StreamOp,
   ): Promise<ChannelDeliveryResult>;
+
+  /**
+   * The most text one stream operation may carry, for a channel that caps it.
+   *
+   * Declared rather than applied here because the caller is what knows how
+   * much of the reply a channel has actually accepted: it must advance that
+   * mark once per operation the channel confirms. A transport that split a
+   * wide delta into several calls of its own would leave the caller unable to
+   * tell a partial delivery from a whole one, and a retry would then re-send
+   * the part that already landed. Omitted by a channel with no cap.
+   */
+  readonly maxStreamTextChars?: number;
+
+  /**
+   * Whether what `streamReply` leaves behind is the reply itself.
+   *
+   * True for a channel that finalizes the streamed message in place, so the
+   * reply is already delivered once the stream ends and durable delivery must
+   * not send it again. Omitted by a channel whose stream is only a preview:
+   * the draft evaporates and the reply is still owed, so durable delivery
+   * sends it as it would for a channel that never streamed.
+   *
+   * Omission is the safe default on purpose. A channel that forgets to
+   * declare it posts the reply through the ordinary path, which at worst
+   * repeats what a persisting stream already showed; the opposite mistake
+   * loses the reply entirely.
+   */
+  readonly streamPersists?: boolean;
 }

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

@@ -9,6 +9,7 @@ import type {
   ApprovalUIMetadata,
   ChannelDeliveryResult,
 } from "@vellumai/gateway-client";
+import { parseDiscordEmojiMention } from "@vellumai/gateway-client";
 
 import { getAttachmentContent } from "../../../persistence/attachments-store.js";
 import type { RuntimeAttachmentMetadata } from "../../../runtime/http-types.js";
@@ -424,8 +425,8 @@ export async function sendDiscordAttachments(
  * as itself.
  */
 function discordReactionPathEmoji(emoji: string): string {
-  const custom = /^<a?:([^:>]+):(\d+)>$/.exec(emoji);
-  return encodeURIComponent(custom ? `${custom[1]}:${custom[2]}` : emoji);
+  const custom = parseDiscordEmojiMention(emoji);
+  return encodeURIComponent(custom ? `${custom.name}:${custom.id}` : emoji);
 }
 
 /**

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

@@ -30,7 +30,17 @@ import {
   type SlackRequestOptions,
 } from "./web-api-transport.js";
 
-/** Envelope fields the outbound surfaces read off successful responses. */
+/**
+ * Envelope fields the outbound surfaces read off successful responses.
+ *
+ * Deliberately no `message_ts`: that is what `chat.postEphemeral` returns
+ * instead of `ts`, and Slack documents it as not addressing a persisted
+ * message (`chat.update` rejects it). So an ephemeral reply has no id worth
+ * recording, and the absent `ts` correctly leaves its row unstamped rather
+ * than carrying a `channelTs` whose permalink resolves to nothing.
+ *
+ * @see https://docs.slack.dev/reference/methods/chat.postEphemeral/
+ */
 interface SlackOutboundApiResponse extends SlackApiResponse {
   ts?: string;
   upload_url?: string;

package/src/messaging/providers/slack/message-metadata.test.ts

@@ -4,9 +4,11 @@ import {
   buildSlackTimezoneMetadata,
   formatSlackTimezoneLabel,
   mergeSlackMetadata,
+  providerMetadataOfPreSendSlackEnvelope,
   readSlackMetadata,
   readSlackMetadataFromMessageMetadata,
   type SlackMessageMetadata,
+  slackViewOfProviderMetadata,
   writeSlackMetadata,
 } from "./message-metadata.js";
 
@@ -394,3 +396,134 @@ describe("mergeSlackMetadata", () => {
     expect(parsed?.displayName).toBe("Bob");
   });
 });
+
+describe("providerMetadataOfPreSendSlackEnvelope", () => {
+  test("reads a pre-send Slack envelope as the neutral shape, Slack's own fields riding along", () => {
+    expect(
+      providerMetadataOfPreSendSlackEnvelope({
+        slackMeta: JSON.stringify({
+          source: "slack",
+          eventKind: "message",
+          channelId: "C1",
+          threadTs: "1700000000.000001",
+          timestampTimezone: "America/New_York",
+        }),
+      }),
+    ).toEqual({
+      source: "slack",
+      conversationExternalId: "C1",
+      eventKind: "message",
+      threadId: "1700000000.000001",
+      timestampTimezone: "America/New_York",
+    });
+  });
+
+  test("reads as null for a reconciled row, a non-Slack envelope, and a row without slackMeta", () => {
+    expect(
+      providerMetadataOfPreSendSlackEnvelope({
+        slackMeta: JSON.stringify({
+          source: "slack",
+          eventKind: "message",
+          channelId: "C1",
+          channelTs: "1700000000.000002",
+        }),
+      }),
+    ).toBeNull();
+    expect(
+      providerMetadataOfPreSendSlackEnvelope({
+        slackMeta: JSON.stringify({ source: "telegram", channelId: "C1" }),
+      }),
+    ).toBeNull();
+    expect(providerMetadataOfPreSendSlackEnvelope({})).toBeNull();
+  });
+});
+
+describe("slackViewOfProviderMetadata", () => {
+  test("maps a Slack reply row's neutral envelope onto the Slack view, extras included", () => {
+    const view = slackViewOfProviderMetadata({
+      source: "slack",
+      conversationExternalId: "C123",
+      messageId: "1700000000.000100",
+      threadId: "1700000000.000001",
+      eventKind: "message",
+      timestampTimezone: "America/New_York",
+      timestampTimezoneLabel: "ET",
+      slackFiles: [{ name: "report.pdf", mimetype: "application/pdf" }],
+      deletedAt: 1700000001000,
+    });
+    expect(view).toEqual({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      threadTs: "1700000000.000001",
+      eventKind: "message",
+      timestampTimezone: "America/New_York",
+      timestampTimezoneLabel: "ET",
+      slackFiles: [{ name: "report.pdf", mimetype: "application/pdf" }],
+      deletedAt: 1700000001000,
+    });
+  });
+
+  test("a reaction row's view stores the reacted message's ts as channelTs", () => {
+    const view = slackViewOfProviderMetadata({
+      source: "slack",
+      conversationExternalId: "C123",
+      eventKind: "reaction",
+      actorExternalId: "U1",
+      displayName: "Alice",
+      reaction: {
+        targetMessageId: "1700000000.000100",
+        emoji: "tada",
+        op: "added",
+        actorDisplayName: "Alice",
+      },
+    });
+    expect(view).toEqual({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      actorExternalUserId: "U1",
+      displayName: "Alice",
+      eventKind: "reaction",
+      reaction: {
+        emoji: "tada",
+        op: "added",
+        targetChannelTs: "1700000000.000100",
+        actorDisplayName: "Alice",
+      },
+    });
+  });
+
+  test("a row naming no post yet, or another channel's row, has no Slack view", () => {
+    expect(
+      slackViewOfProviderMetadata({
+        source: "slack",
+        conversationExternalId: "C123",
+        eventKind: "message",
+      }),
+    ).toBeNull();
+    expect(
+      slackViewOfProviderMetadata({
+        source: "discord",
+        conversationExternalId: "999",
+        messageId: "1",
+        eventKind: "message",
+      }),
+    ).toBeNull();
+  });
+
+  test("readSlackMetadataFromMessageMetadata serves the neutral envelope before the nested one", () => {
+    const metadata = JSON.stringify({
+      assistantMessageChannel: "slack",
+      providerMeta: JSON.stringify({
+        source: "slack",
+        conversationExternalId: "C123",
+        messageId: "1700000000.000100",
+        eventKind: "message",
+      }),
+    });
+    expect(readSlackMetadataFromMessageMetadata(metadata)?.channelTs).toBe(
+      "1700000000.000100",
+    );
+  });
+});

package/src/messaging/providers/slack/message-metadata.ts

@@ -1,6 +1,14 @@
+import {
+  pickReactionEmojiFields,
+  ReactionEmojiFieldsSchema,
+} from "@vellumai/service-contracts/reactions";
 import { z } from "zod";
 
-import type { ProviderMessageMetadata } from "../../provider-message-metadata.js";
+import { safeParseRecord } from "../../../util/json.js";
+import {
+  type ProviderMessageMetadata,
+  readProviderMessageMetadata,
+} from "../../provider-message-metadata.js";
 
 /**
  * Typed Slack message metadata stored flat in the `messages.metadata` column
@@ -39,6 +47,7 @@ export function isSlackDmConversation(conversationExternalId: string): boolean {
 
 const slackReactionMetadataSchema = z.object({
   emoji: z.string(),
+  ...ReactionEmojiFieldsSchema.shape,
   actorDisplayName: z.string().optional(),
   targetChannelTs: z.string(),
   op: z.enum(["added", "removed"]),
@@ -258,6 +267,13 @@ export function readSlackMetadata(
   return result.success ? result.data : null;
 }
 
+/**
+ * Read a row's Slack view from its stored metadata, whichever envelope the
+ * row carries: the neutral `providerMeta` (every row the daemon authors, and
+ * the end state for every Slack row) or the nested `slackMeta` that inbound
+ * Slack rows still write. `allowFlatLegacy` also accepts the pre-envelope
+ * flat form.
+ */
 export function readSlackMetadataFromMessageMetadata(
   metadata: string | null | undefined,
   opts?: { allowFlatLegacy?: boolean },
@@ -279,6 +295,18 @@ export function readSlackMetadataFromMessageMetadata(
     return null;
   }
 
+  // A row the daemon authors (an assistant reply, its own reaction, a
+  // bot-authored backfill row) describes itself in the neutral envelope;
+  // its Slack view is derived from that, so every Slack reader serves both
+  // envelopes without a branch of its own.
+  const neutral = readProviderMessageMetadata(parent.providerMeta);
+  if (neutral !== null) {
+    const view = slackViewOfProviderMetadata(neutral);
+    if (view !== null) {
+      return view;
+    }
+  }
+
   const nested = parent.slackMeta;
   if (typeof nested === "string") {
     const parsedNested = readSlackMetadata(nested);
@@ -290,6 +318,80 @@ export function readSlackMetadataFromMessageMetadata(
   return opts?.allowFlatLegacy ? readSlackMetadata(metadata) : null;
 }
 
+/**
+ * Slack's own fields, carried on the neutral envelope's passthrough by rows
+ * that write it. They have no neutral counterpart: the Slack transcript
+ * renderer is a provider renderer by design and reads them through the
+ * Slack view.
+ */
+const SLACK_ONLY_FIELDS = [
+  "channelName",
+  "timestampTimezone",
+  "timestampTimezoneLabel",
+  "speakerTimezoneLabel",
+  "actorTimezone",
+  "actorTimezoneLabel",
+  "actorTimezoneOffsetSeconds",
+  "slackFiles",
+] as const;
+
+/**
+ * The Slack view of a neutral envelope: the inverse of
+ * `slackMetadataAsProviderMetadata`, for the Slack renderers and the backfill
+ * readers. A reaction row's `channelTs` is the reacted message's ts, as the
+ * Slack envelope stores it. Null for a non-Slack envelope, and for one that
+ * names no post yet (a reply before its post-send reconciliation), which is
+ * also what the strict reader says of a pre-send Slack envelope.
+ */
+export function slackViewOfProviderMetadata(
+  meta: ProviderMessageMetadata,
+): SlackMessageMetadata | null {
+  if (meta.source !== "slack") {
+    return null;
+  }
+  const channelTs =
+    meta.eventKind === "reaction"
+      ? meta.reaction?.targetMessageId
+      : meta.messageId;
+  if (channelTs === undefined) {
+    return null;
+  }
+  const candidate: Record<string, unknown> = {
+    source: "slack",
+    channelId: meta.conversationExternalId,
+    channelTs,
+    ...(meta.threadId !== undefined ? { threadTs: meta.threadId } : {}),
+    ...(meta.displayName !== undefined
+      ? { displayName: meta.displayName }
+      : {}),
+    ...(meta.actorExternalId !== undefined
+      ? { actorExternalUserId: meta.actorExternalId }
+      : {}),
+    eventKind: meta.eventKind,
+    ...(meta.reaction
+      ? {
+          reaction: {
+            emoji: meta.reaction.emoji,
+            op: meta.reaction.op,
+            targetChannelTs: meta.reaction.targetMessageId,
+            ...(meta.reaction.actorDisplayName
+              ? { actorDisplayName: meta.reaction.actorDisplayName }
+              : {}),
+          },
+        }
+      : {}),
+    ...(meta.editedAt !== undefined ? { editedAt: meta.editedAt } : {}),
+    ...(meta.deletedAt !== undefined ? { deletedAt: meta.deletedAt } : {}),
+  };
+  for (const field of SLACK_ONLY_FIELDS) {
+    if (meta[field] !== undefined) {
+      candidate[field] = meta[field];
+    }
+  }
+  const result = slackMessageMetadataSchema.safeParse(candidate);
+  return result.success ? result.data : null;
+}
+
 /**
  * Present a Slack row's stored metadata as the channel-neutral shape.
  *
@@ -321,6 +423,7 @@ export function slackMetadataAsProviderMetadata(
           reaction: {
             targetMessageId: meta.reaction.targetChannelTs,
             emoji: meta.reaction.emoji,
+            ...pickReactionEmojiFields(meta.reaction),
             op: meta.reaction.op,
             ...(meta.reaction.actorDisplayName
               ? { actorDisplayName: meta.reaction.actorDisplayName }
@@ -333,6 +436,43 @@ export function slackMetadataAsProviderMetadata(
   };
 }
 
+/**
+ * The neutral envelope of a reply row reserved with Slack's own pre-send
+ * envelope: a `slackMeta` naming the channel and thread but no `channelTs`,
+ * the id the post-send reconciliation fills in.
+ *
+ * Transitional: a reply the daemon reserves carries the neutral envelope from
+ * the start, so this serves only a reply still pending for the retry sweep
+ * that a daemon reserving Slack replies under `slackMeta` left there; the
+ * reconciliation stamps it and converges the row onto the neutral envelope,
+ * Slack's own fields riding the schema's passthrough. Delete once no such
+ * row can be pending. A `slackMeta` that already names its post is a
+ * reconciled row and reads as null here; `readSlackMetadata` serves it.
+ */
+export function providerMetadataOfPreSendSlackEnvelope(
+  envelope: Record<string, unknown>,
+): ProviderMessageMetadata | null {
+  if (typeof envelope.slackMeta !== "string") {
+    return null;
+  }
+  const { source, channelId, channelTs, threadTs, ...slackFields } =
+    safeParseRecord(envelope.slackMeta);
+  if (
+    source !== "slack" ||
+    typeof channelId !== "string" ||
+    channelTs !== undefined
+  ) {
+    return null;
+  }
+  return {
+    ...slackFields,
+    source: "slack",
+    conversationExternalId: channelId,
+    eventKind: "message",
+    ...(typeof threadTs === "string" ? { threadId: threadTs } : {}),
+  };
+}
+
 /**
  * Serialize `SlackMessageMetadata` to a JSON string suitable for a fresh
  * write to the `messages.metadata` column. Use `mergeSlackMetadata` when an

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

@@ -10,7 +10,13 @@ type CallSlackApi = typeof import("./api.js").callSlackApi;
 
 const callSlackApiMock = mock<CallSlackApi>(async () => ({ ok: true }));
 
+// Spread the real module so a factory listing only what today's tests touch
+// cannot break the next import send.ts adds; the stubs below then override
+// exactly the calls this suite asserts on.
+const actualSlackApi = await import("./api.js");
+
 mock.module("./api.js", () => ({
+  ...actualSlackApi,
   callSlackApi: (method: string, body: Record<string, unknown>) =>
     callSlackApiMock(method, body),
   callSlackApiForm: async () => ({}),
@@ -32,8 +38,10 @@ const {
   sendSlackAgentSessionStatus,
   sendSlackReaction,
   sendSlackReply,
+  sendSlackStreamOp,
   updateSlackMessage,
 } = await import("./send.js");
+const { SLACK_STREAM_MARKDOWN_LIMIT } = await import("./api.js");
 
 describe("sendSlackAgentSessionStatus", () => {
   const threadTs = "1700000000.000100";
@@ -442,3 +450,53 @@ describe("sendSlackReply approval fallback", () => {
     expect(callSlackApiMock).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("sendSlackStreamOp", () => {
+  const streamTs = "1700000000.000900";
+
+  beforeEach(() => {
+    callSlackApiMock.mockReset();
+    callSlackApiMock.mockImplementation(async () => ({ ok: true }));
+  });
+
+  test("sends one call per operation, whatever the caller hands over", async () => {
+    // Splitting to fit the cap belongs to the caller, which is what tracks how
+    // much of the reply Slack has taken. This layer performs the operation it
+    // is given, once.
+    const appended = "x".repeat(SLACK_STREAM_MARKDOWN_LIMIT);
+    await sendSlackStreamOp("C-STREAM", {
+      action: "append",
+      streamId: streamTs,
+      text: appended,
+      appended,
+    });
+
+    const calls = callSlackApiMock.mock.calls.filter(
+      (call) => call[0] === "chat.appendStream",
+    );
+    expect(calls).toHaveLength(1);
+    expect((calls[0]![1] as { markdownText?: string }).markdownText).toBe(
+      appended,
+    );
+  });
+
+  test("a plan that moved with no new words still reaches the message", async () => {
+    // `chat.appendStream` documents "One of markdown_text or chunks is
+    // required", so a plan-only call is legal and is what ticks the plan block
+    // during silent work.
+    await sendSlackStreamOp("C-STREAM", {
+      action: "append",
+      streamId: streamTs,
+      text: "unchanged",
+      plan: { steps: [{ label: "Step", status: "completed" }] },
+    });
+
+    const calls = callSlackApiMock.mock.calls.filter(
+      (call) => call[0] === "chat.appendStream",
+    );
+    expect(calls).toHaveLength(1);
+    const body = calls[0]![1] as { markdownText?: string; tasks?: unknown };
+    expect(body.markdownText).toBeUndefined();
+    expect(body.tasks).toBeDefined();
+  });
+});

package/src/messaging/providers/slack/send.ts

@@ -331,10 +331,10 @@ export async function sendSlackStreamOp(
         channel,
         threadTs: op.anchorMessageId,
         markdownText: op.appended ?? op.text,
-        // Fixed for the stream's lifetime at start, while a plan usually
-        // arrives after the first text flush has opened it. It only affects
-        // how task chunks render, so a stream that never carries a plan still
-        // reads as a plain message.
+        // Fixed for the stream's lifetime at start, so it is set
+        // unconditionally: a plan that first appears on a later append still
+        // renders as a plan. It only affects how task chunks render, so a
+        // stream that never carries one still reads as a plain message.
         taskDisplayMode: "plan",
         planTitle,
         tasks,