@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/runtime/{slack-reply-session.test.ts → channel-reply-session.test.ts}

@@ -22,7 +22,22 @@ let streamOpImpl: (op: StreamOp) => Promise<{
   ok: boolean;
   ts?: string;
 }> = async () => ({ ok: true, ts: "stream-ts-1" });
+/**
+ * What the transport lookup reports for the callback under test. A channel
+ * declares it can stream by implementing the method, so `undefined` here is a
+ * channel that cannot, and `streamPersists` is what says whether the stream
+ * leaves the reply behind.
+ */
+let transportImpl:
+  | {
+      streamReply?: unknown;
+      streamPersists?: boolean;
+      maxStreamTextChars?: number;
+    }
+  | undefined = { streamReply: () => undefined, streamPersists: true };
+
 mock.module("../messaging/providers/index.js", () => ({
+  getTransportForCallback: () => transportImpl,
   sendChannelStreamOp: async (
     _callbackUrl: string,
     _chatId: string,
@@ -53,11 +68,10 @@ mock.module("./gateway-client.js", () => ({
 }));
 
 import type { AssistantEvent } from "../api/index.js";
-import { SLACK_STREAM_MARKDOWN_LIMIT } from "../messaging/providers/slack/api.js";
 import {
-  createSlackReplySession,
-  shouldStreamSlackReply,
-} from "./slack-reply-session.js";
+  channelCanStreamReply,
+  createChannelReplySession,
+} from "./channel-reply-session.js";
 
 const CHANNEL = "D-STREAM";
 const THREAD_TS = "1700000000.000001";
@@ -155,105 +169,122 @@ const streamedMarkdown = (): string =>
     .join("");
 
 beforeEach(() => {
+  // A channel that streams and whose stream is the reply, which is what the
+  // suite below assumes unless a test says otherwise.
+  transportImpl = { streamReply: () => undefined, streamPersists: true };
   deliverCalls.length = 0;
   sentStreamOps.length = 0;
   streamOpImpl = async () => ({ ok: true, ts: "stream-ts-1" });
   deliverImpl = async () => ({ ok: true, ts: "stream-ts-1" });
 });
 
-describe("shouldStreamSlackReply", () => {
-  test("admits a threaded Slack DM", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
-        chatType: "im",
-        replyCallbackUrl: CALLBACK_URL,
-      }),
-    ).toBe(true);
+describe("channelCanStreamReply", () => {
+  test("a channel whose transport implements streamReply can stream", () => {
+    transportImpl = { streamReply: () => undefined, streamPersists: true };
+    expect(channelCanStreamReply(CALLBACK_URL)).toBe(true);
   });
 
-  test("rejects a DM whose callback URL carries no thread_ts", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
-        chatType: "im",
-        replyCallbackUrl: `https://example.test/deliver/slack?channel=${CHANNEL}`,
-      }),
-    ).toBe(false);
+  test("a channel whose transport omits streamReply cannot", () => {
+    // Omitting the method is how a channel with no such primitive declares
+    // it, so there is nothing else to consult.
+    transportImpl = { streamPersists: false };
+    expect(channelCanStreamReply(CALLBACK_URL)).toBe(false);
   });
 
-  test("admits a channel turn carrying both recipient IDs", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
-        chatType: "channel",
-        replyCallbackUrl: CALLBACK_URL,
-        recipientUserId: "U123",
-        recipientTeamId: "T123",
-      }),
-    ).toBe(true);
+  test("no callback URL is no channel to ask", () => {
+    expect(channelCanStreamReply(undefined)).toBe(false);
   });
 
-  test("admits an app-mention turn (no chatType) carrying both recipient IDs", () => {
+  test("a session is not created for a channel that cannot stream", () => {
+    transportImpl = undefined;
     expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
+      createChannelReplySession({
         replyCallbackUrl: CALLBACK_URL,
-        recipientUserId: "U123",
-        recipientTeamId: "T123",
+        chatId: CHANNEL,
       }),
-    ).toBe(true);
+    ).toBeUndefined();
   });
+});
 
-  test("rejects a channel turn missing the recipient team ID", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
-        chatType: "channel",
-        replyCallbackUrl: CALLBACK_URL,
-        recipientUserId: "U123",
-      }),
-    ).toBe(false);
+describe("createChannelReplySession", () => {
+  test("a start the channel refuses falls back without streaming", async () => {
+    // Whether THIS conversation can carry a growing reply is the platform's
+    // rule, answered by the transport's own reply to `start`. Slack refusing
+    // a turn with no thread, and Telegram refusing a chat that is not
+    // private, both arrive here as the same not-ok.
+    streamOpImpl = async () => ({ ok: false });
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+    })!;
+
+    session.observeEvent(textDelta("The complete answer."));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    const reconciliation = await session.finish();
+
+    expect(slackStreamOps().map((op) => op.action)).toEqual(["start"]);
+    expect(reconciliation).toEqual({ mode: "fallback" });
   });
 
-  test("rejects a channel turn missing the recipient user ID", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "slack",
-        chatType: "channel",
-        replyCallbackUrl: CALLBACK_URL,
-        recipientTeamId: "T123",
-      }),
-    ).toBe(false);
+  test("a preview stream leaves the reply still owed", async () => {
+    // Telegram's draft evaporates rather than becoming the reply, so a
+    // channel that does not persist its stream reports `fallback`: durable
+    // delivery still sends the reply, exactly as for a channel that never
+    // streamed. Reporting `streamed` here would drop the reply entirely.
+    transportImpl = { streamReply: () => undefined, streamPersists: false };
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+    })!;
+
+    session.observeEvent(textDelta("The complete answer."));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    const reconciliation = await session.finish();
+
+    // The preview really was streamed...
+    expect(slackStreamOps().map((op) => op.action)).toEqual(["start", "stop"]);
+    // ...and the reply is still owed.
+    expect(reconciliation).toEqual({ mode: "fallback" });
   });
 
-  test("rejects non-Slack channels", () => {
-    expect(
-      shouldStreamSlackReply({
-        sourceChannel: "telegram",
-        chatType: "im",
-        replyCallbackUrl: CALLBACK_URL,
-      }),
-    ).toBe(false);
+  test("a preview stream never records an id for crash recovery", async () => {
+    // The breadcrumb exists so a retry can reconcile against a message the
+    // reader can already see. A preview leaves none, and its id names nothing
+    // durable, so recording it would send recovery to edit a message that
+    // never existed and lose the reply instead of posting it.
+    transportImpl = { streamReply: () => undefined, streamPersists: false };
+    const opened: string[] = [];
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+      onStreamOpen: (ts) => opened.push(ts),
+    })!;
+
+    session.observeEvent(textDelta("The complete answer."));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    await session.finish();
+
+    expect(slackStreamOps().map((op) => op.action)).toEqual(["start", "stop"]);
+    expect(opened).toEqual([]);
   });
-});
 
-describe("createSlackReplySession", () => {
-  test("returns undefined for an ineligible turn", () => {
-    expect(
-      createSlackReplySession({
-        sourceChannel: "slack",
-        chatType: "channel",
-        replyCallbackUrl: CALLBACK_URL,
-        chatId: CHANNEL,
-      }),
-    ).toBeUndefined();
+  test("a stream that becomes the reply does record its id", async () => {
+    const opened: string[] = [];
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+      onStreamOpen: (ts) => opened.push(ts),
+    })!;
+
+    session.observeEvent(textDelta("The complete answer."));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    await session.finish();
+
+    expect(opened).toEqual(["stream-ts-1"]);
   });
 
   test("streams a fast turn as a single start then stop", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -266,7 +297,6 @@ describe("createSlackReplySession", () => {
     expect(slackStreamOps()).toEqual([
       {
         action: "start",
-        anchorMessageId: THREAD_TS,
         text: "The complete answer.",
         appended: "The complete answer.",
       },
@@ -284,9 +314,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("stamps recipient IDs on the start op for a channel turn", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "channel",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       recipientUserId: "U123",
@@ -301,7 +329,6 @@ describe("createSlackReplySession", () => {
     expect(slackStreamOps()).toEqual([
       {
         action: "start",
-        anchorMessageId: THREAD_TS,
         text: "The complete answer.",
         appended: "The complete answer.",
         audience: { kind: "oneReader", userId: "U123", userOrgId: "T123" },
@@ -315,9 +342,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("coalesces mid-stream deltas into incremental appends", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -332,7 +357,6 @@ describe("createSlackReplySession", () => {
     expect(slackStreamOps()).toEqual([
       {
         action: "start",
-        anchorMessageId: THREAD_TS,
         text: "First half. ",
         appended: "First half. ",
       },
@@ -351,32 +375,101 @@ describe("createSlackReplySession", () => {
     expect(reconciliation.mode).toBe("streamed");
   });
 
-  test("drains a body wider than the markdown limit across calls", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+  test("drains a body wider than the channel's cap, one operation per chunk", async () => {
+    transportImpl = {
+      streamReply: () => undefined,
+      streamPersists: true,
+      maxStreamTextChars: 10,
+    };
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+    })!;
+
+    const body = "abcdefghijKLMNOPQRSTuvwxy";
+    session.observeEvent(textDelta(body));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    await session.finish();
+
+    const ops = slackStreamOps();
+    expect(ops.map((op) => op.action)).toEqual([
+      "start",
+      "append",
+      "append",
+      "stop",
+    ]);
+    // Every chunk fits the cap, and together they are the whole reply.
+    expect(ops[0]!.appended).toBe("abcdefghij");
+    expect(ops[1]!.appended).toBe("KLMNOPQRST");
+    expect(ops[2]!.appended).toBe("uvwxy");
+  });
+
+  test("a failed chunk resumes at itself, never at what already landed", async () => {
+    // The delivered mark advances once per confirmed operation, so a retry
+    // begins at the chunk that failed. Advancing it for a delta the channel
+    // only partly took would resume past unsent text, or re-send text the
+    // reader can already see.
+    transportImpl = {
+      streamReply: () => undefined,
+      streamPersists: true,
+      maxStreamTextChars: 10,
+    };
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
+      coalesceMs: 5,
     })!;
 
-    const body = "x".repeat(SLACK_STREAM_MARKDOWN_LIMIT + 4_000);
+    let failNextAppend = true;
+    streamOpImpl = async (op) => {
+      if (op.action === "append" && failNextAppend) {
+        failNextAppend = false;
+        throw new Error("Simulated append failure");
+      }
+      return { ok: true, ts: "stream-ts-1" };
+    };
+
+    session.observeEvent(textDelta("abcdefghijKLMNOPQRST"));
+    await tick(15);
+    session.observeEvent(textDelta("uvwxy"));
+    await tick(15);
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    await session.finish();
+
+    const appended = slackStreamOps()
+      .filter((op) => op.action === "append")
+      .map((op) => op.appended);
+    // The first attempt at "KLMNOPQRST" fails and is retried; nothing that
+    // landed is ever sent a second time.
+    expect(appended[0]).toBe("KLMNOPQRST");
+    expect(appended[1]).toBe("KLMNOPQRST");
+    expect(appended.filter((c) => c === "abcdefghij")).toHaveLength(0);
+    expect(appended.at(-1)).toBe("uvwxy");
+  });
+
+  test("hands a body of any width over as one delta", async () => {
+    // Splitting belongs to the channel whose API sets the cap, so the session
+    // must not pre-split: a channel with a wider cap, or none, would be paying
+    // for Slack's. What it owes is the whole delta, once.
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+    })!;
+
+    const body = "x".repeat(20_000);
     session.observeEvent(textDelta(body));
     session.observeEvent(messageComplete("assistant-msg-1"));
     await session.finish();
 
     const ops = slackStreamOps();
-    expect(ops.map((op) => op.action)).toEqual(["start", "append", "stop"]);
-    expect((ops[0]!.appended ?? "").length).toBe(SLACK_STREAM_MARKDOWN_LIMIT);
-    expect((ops[1]!.appended ?? "").length).toBe(4_000);
-    const streamed = (ops[0]!.appended ?? "") + (ops[1]!.appended ?? "");
-    expect(streamed).toBe(body);
+    expect(ops.map((op) => op.action)).toEqual(["start", "stop"]);
+    expect(ops[0]!.appended).toBe(body);
+    expect(ops[0]!.text).toBe(body);
   });
 
   test("falls back when startStream returns no stream ts", async () => {
     streamOpImpl = async () => ({ ok: false });
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -393,9 +486,7 @@ describe("createSlackReplySession", () => {
     streamOpImpl = async () => {
       throw new Error("rate limited");
     };
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -414,9 +505,7 @@ describe("createSlackReplySession", () => {
       }
       return { ok: true, ts: "stream-ts-1" };
     };
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -435,9 +524,7 @@ describe("createSlackReplySession", () => {
     // transient breadcrumb write error) must not knock the session into
     // fallback — that would repost the already-visible streamed reply.
     const onStreamOpenCalls: string[] = [];
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       onStreamOpen: (streamTs) => {
@@ -466,9 +553,7 @@ describe("createSlackReplySession", () => {
     // `chat.appendStream` accepts a chunks-only call, so a plan that advances
     // during tool work lands live instead of waiting for the final stop.
     // @see https://docs.slack.dev/reference/methods/chat.appendStream/
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -522,9 +607,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("does not re-append unchanged task progress", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -548,9 +631,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("does not advance a plan the surface tool rejected", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -598,9 +679,7 @@ describe("createSlackReplySession", () => {
       }
       return { ok: true, ts: "stream-ts-1" };
     };
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -639,9 +718,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("never opens a stream for a no_response-only turn", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -657,9 +734,7 @@ describe("createSlackReplySession", () => {
   test("holds the stream while a no_response sentinel arrives in pieces", async () => {
     // A coalesce timer must not open a stream on the leading `<` of a slowly
     // streamed `<no_response/>`, which would leak a stray partial message.
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -685,9 +760,7 @@ describe("createSlackReplySession", () => {
     // Slack streams are append-only, so a `[label](vellum://…)` link split
     // across deltas must not stream its internal path before the closing `)`
     // arrives — once emitted it could not be retracted.
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -714,9 +787,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("counts deliverable text segments split at tool boundaries", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -738,9 +809,7 @@ describe("createSlackReplySession", () => {
     // The model ends one segment with a period and opens the next with a
     // capital letter, supplying no separating whitespace on either side.
     // Concatenating them raw would fuse "Sentence one.Sentence two.".
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -758,9 +827,7 @@ describe("createSlackReplySession", () => {
     // Multiple `message_complete` events fire within one streamed turn (one
     // per model response). Text from the second response must not fuse onto
     // the first.
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -775,9 +842,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("does not double-space a boundary the model already spaced", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -794,9 +859,7 @@ describe("createSlackReplySession", () => {
   test("does not fuse mid-word deltas within a single segment", async () => {
     // Intra-segment token deltas carry the model's own spacing and must never
     // be altered — only tool/message boundaries introduce a separating space.
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
     })!;
@@ -811,9 +874,7 @@ describe("createSlackReplySession", () => {
   });
 
   test("opens the stream in plan mode and advances task cards", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -841,7 +902,6 @@ describe("createSlackReplySession", () => {
     const ops = slackStreamOps();
     expect(ops[0]).toEqual({
       action: "start",
-      anchorMessageId: THREAD_TS,
       text: "Working on it.",
       appended: "Working on it.",
       plan: {
@@ -871,9 +931,7 @@ describe("createSlackReplySession", () => {
     // stream starts, so the start must open in plan mode even with no plan
     // active yet — otherwise the late-arriving task cards can never render
     // as a plan.
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -895,7 +953,6 @@ describe("createSlackReplySession", () => {
     expect(slackStreamOps()).toEqual([
       {
         action: "start",
-        anchorMessageId: THREAD_TS,
         text: "On it, starting now.",
         appended: "On it, starting now.",
       },
@@ -924,10 +981,92 @@ describe("createSlackReplySession", () => {
     ]);
   });
 
+  test("opens the stream on a plan shown before any prose", async () => {
+    // What the Slack `ui_show` description actually instructs: show the card
+    // early on a multi-step turn. At that moment the model has written no
+    // prose, so a stream that waits for text holds the plan back until the
+    // final answer, when the steps it narrates are already finished.
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+      coalesceMs: 5,
+    })!;
+
+    session.observeEvent(
+      taskProgressShow([
+        { label: "Search docs", status: "in_progress" },
+        { label: "Summarize", status: "pending" },
+      ]),
+    );
+    session.observeEvent(toolOk("tool-ui-show", "ui_show"));
+    await tick(15);
+
+    // The plan is on Slack before the turn has produced a single character.
+    expect(slackStreamOps()).toEqual([
+      {
+        action: "start",
+        text: "",
+        appended: "",
+        plan: {
+          steps: [
+            { label: "Search docs", status: "in_progress" },
+            { label: "Summarize", status: "pending" },
+          ],
+        },
+      },
+    ]);
+  });
+
+  test("advances plan steps live while the turn is still working", async () => {
+    const session = createChannelReplySession({
+      replyCallbackUrl: CALLBACK_URL,
+      chatId: CHANNEL,
+      coalesceMs: 5,
+    })!;
+
+    session.observeEvent(
+      taskProgressShow([
+        { label: "Search docs", status: "in_progress" },
+        { label: "Summarize", status: "pending" },
+      ]),
+    );
+    session.observeEvent(toolOk("tool-ui-show", "ui_show"));
+    await tick(15);
+    session.observeEvent(
+      taskProgressUpdate([
+        { label: "Search docs", status: "completed" },
+        { label: "Summarize", status: "in_progress" },
+      ]),
+    );
+    session.observeEvent(toolOk("tool-ui-update", "ui_update"));
+    await tick(15);
+
+    // The advance rides its own task-only append rather than waiting for the
+    // first text, which is the whole point of a live step tracker.
+    const advances = slackStreamOps().filter((op) => op.action === "append");
+    expect(advances).toHaveLength(1);
+    expect(advances[0].plan).toEqual({
+      steps: [
+        { label: "Search docs", status: "completed" },
+        { label: "Summarize", status: "in_progress" },
+      ],
+    });
+
+    session.observeEvent(textDelta("All done."));
+    session.observeEvent(messageComplete("assistant-msg-1"));
+    const reconciliation = await session.finish();
+
+    // The reply still streams into the same message the plan opened.
+    expect(reconciliation).toEqual({
+      mode: "streamed",
+      messageTs: "stream-ts-1",
+      deliveredSegmentCount: 1,
+    });
+    expect(streamedMarkdown()).toBe("All done.");
+  });
+
   test("carries the plan title and step details onto stream ops", async () => {
-    const session = createSlackReplySession({
-      sourceChannel: "slack",
-      chatType: "im",
+    const session = createChannelReplySession({
       replyCallbackUrl: CALLBACK_URL,
       chatId: CHANNEL,
       coalesceMs: 5,
@@ -955,7 +1094,6 @@ describe("createSlackReplySession", () => {
     const ops = slackStreamOps();
     expect(ops[0]).toEqual({
       action: "start",
-      anchorMessageId: THREAD_TS,
       text: "Working on it.",
       appended: "Working on it.",
       plan: {