fix(telegram): confine stream-off accumulator to streaming.mode=off

anagnorisis2peripeteia · anagnorisis2peripeteia · commit 86b71f2f3c80 · 2026-06-06T18:08:43.000+01:00
Moving the progress-set flush to the common final path made it fire on the
bare absence of an answer-lane draft (!answerLane.stream), which is also true
in partial/progress turns that lack a live draft (e.g. selected-quote replies)
— so those turns could get a surprise durable progress message.

Gate accumulation, suppressed-source callback forwarding, and emission on a
single streamOffPersistEnabled = persistProgressEnabled &amp;&amp; streamMode === 'off'
so the accumulator only ever engages in genuine stream-off turns. Regression:
a no-draft partial-mode turn with persistProgress emits no progress set.
diff --git a/extensions/telegram/src/bot-message-dispatch.test.ts b/extensions/telegram/src/bot-message-dispatch.test.ts
@@ -1551,6 +1551,50 @@ describe("dispatchTelegramMessage draft streaming", () => {
     expect(progress.mediaUrls).toBeUndefined();
   });
 
+  it("does not emit the stream-off progress set in a no-draft non-off turn", async () => {
+    // The accumulator is a streaming.mode === "off" mechanism. In partial/progress turns
+    // that merely lack a live draft (e.g. selected-quote replies), it must stay inert and
+    // not deliver a surprise durable progress message.
+    deliverInboundReplyWithMessageSendContext.mockResolvedValue({
+      delivery: { messageId: 9100 },
+    });
+    dispatchReplyWithBufferedBlockDispatcher.mockImplementation(
+      async ({ dispatcherOptions, replyOptions }) => {
+        await replyOptions?.onItemEvent?.({
+          kind: "preamble",
+          itemId: "c1",
+          progressText: "Looking into it.",
+        });
+        await replyOptions?.onToolStart?.({
+          name: "Read",
+          phase: "start",
+          args: { file_path: "/x.md" },
+        });
+        await dispatcherOptions.deliver({ text: "Done." }, { kind: "final" });
+        return { queuedFinal: true };
+      },
+    );
+    deliverReplies.mockResolvedValue({ delivered: true });
+
+    // partial mode with NO draft stream set up (createTelegramDraftStream returns undefined)
+    await dispatchWithContext({
+      context: createContext(),
+      streamMode: "partial",
+      telegramCfg: {
+        streaming: {
+          mode: "partial",
+          progress: { persistProgress: true, commentary: true, toolProgress: true },
+        },
+      },
+    });
+
+    const progressSets = deliverInboundReplyWithMessageSendContext.mock.calls.filter((call) => {
+      const text = (call[0] as { payload?: { text?: string } })?.payload?.text;
+      return typeof text === "string" && text.includes("💭");
+    });
+    expect(progressSets.length).toBe(0);
+  });
+
   it("suppresses text-only tool payloads delivered after the final answer", async () => {
     const { answerDraftStream } = setupDraftStreams({ answerMessageId: 2001 });
     dispatchReplyWithBufferedBlockDispatcher.mockImplementation(async ({ dispatcherOptions }) => {
diff --git a/extensions/telegram/src/bot-message-dispatch.ts b/extensions/telegram/src/bot-message-dispatch.ts
@@ -909,6 +909,13 @@ export const dispatchTelegramMessage = async ({
   const progressSeed = `${route.accountId}:${chatId}:${threadSpec.id ?? ""}`;
   const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
   const persistProgressEnabled = resolveChannelStreamingProgressPersist(telegramCfg);
+  // The stream-off accumulator (#89890) is strictly a streaming.mode === "off" mechanism:
+  // it buffers tool/commentary progress and emits it as a durable message before the
+  // answer. It must NOT engage in partial/progress turns that merely lack a live draft
+  // (e.g. selected-quote replies), or those turns would get a surprise durable progress
+  // message. Gate accumulation, callback-forwarding, and emission on this — not on the
+  // bare absence of a draft stream.
+  const streamOffPersistEnabled = persistProgressEnabled && streamMode === "off";
   const createDraftLane = (laneName: LaneName, enabled: boolean): DraftLaneState => {
     const stream = enabled
       ? (telegramDeps.createTelegramDraftStream ?? createTelegramDraftStream)({
@@ -1768,7 +1775,7 @@ export const dispatchTelegramMessage = async ({
                       // stream-ON path (which persists the live progress message in place) does
                       // not double-emit. Awaited here so the set lands before the answer (barrier).
                       if (
-                        !persistProgressEnabled ||
+                        !streamOffPersistEnabled ||
                         answerLane.stream ||
                         persistedProgressLog.length === 0
                       ) {
@@ -2099,7 +2106,7 @@ export const dispatchTelegramMessage = async ({
                   suppressDefaultToolProgressMessages:
                     !streamDeliveryEnabled || Boolean(answerLane.stream),
                   allowProgressCallbacksWhenSourceDeliverySuppressed:
-                    !isRoomEvent && (Boolean(answerLane.stream) || persistProgressEnabled),
+                    !isRoomEvent && (Boolean(answerLane.stream) || streamOffPersistEnabled),
                   onToolStart: async (payload) => {
                     const toolName = payload.name?.trim();
                     const progressPromise = pushStreamToolProgress(
@@ -2116,7 +2123,7 @@ export const dispatchTelegramMessage = async ({
                       { toolName, startImmediately: true },
                     );
                     if (
-                      persistProgressEnabled &&
+                      streamOffPersistEnabled &&
                       toolName &&
                       resolveChannelStreamingProgressToolProgressEnabled(telegramCfg)
                     ) {
@@ -2136,7 +2143,7 @@ export const dispatchTelegramMessage = async ({
                   onItemEvent: async (payload) => {
                     if (payload.kind === "preamble") {
                       if (
-                        persistProgressEnabled &&
+                        streamOffPersistEnabled &&
                         resolveChannelStreamingProgressCommentaryEnabled(telegramCfg) &&
                         payload.progressText
                       ) {
