fix(telegram): force fresh final after visible intermediate output (#76529)

extensions/telegram/src/bot-message-dispatch.test.ts

@@ -3213,6 +3213,44 @@ describe("dispatchTelegramMessage draft streaming", () => {
     expect(draftStream.clear).not.toHaveBeenCalled();
   });
 
+  // #76529: when a visible non-final message is delivered after the answer
+  // preview is already on screen, finalizing the preview by edit puts the
+  // final answer above the intermediate output. Force a fresh send instead.
+  it("sends a fresh final after a visible block bubble pushes the preview up (#76529)", async () => {
+    // Preview was already on screen before the block bubble was sent.
+    const draftStream = createTestDraftStream({
+      messageId: 999,
+      visibleSinceMs: Date.now() - 1_000,
+    });
+    createTelegramDraftStream.mockReturnValue(draftStream);
+    editMessageTelegram.mockResolvedValue({ ok: true });
+    dispatchReplyWithBufferedBlockDispatcher.mockImplementation(
+      async ({ dispatcherOptions, replyOptions }) => {
+        await replyOptions?.onPartialReply?.({ text: "Checked maxDBdays..." });
+        await dispatcherOptions.deliver(
+          { text: "Changed maxDBdays from 91 → 14" },
+          { kind: "block" },
+        );
+        await dispatcherOptions.deliver({ text: "Done" }, { kind: "final" });
+        return { queuedFinal: true };
+      },
+    );
+    deliverReplies.mockResolvedValue({ delivered: true });
+
+    await dispatchWithContext({ context: createContext() });
+
+    // Block + fresh final both went through deliverReplies; preview was not
+    // edited in place and the stale preview was cleared.
+    expect(deliverReplies).toHaveBeenCalledTimes(2);
+    expect(editMessageTelegram).not.toHaveBeenCalled();
+    expect(deliverReplies).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        replies: [expect.objectContaining({ text: "Done" })],
+      }),
+    );
+    expect(draftStream.clear).toHaveBeenCalled();
+  });
+
   it("cleans up preview even when fallback delivery throws (double failure)", async () => {
     const draftStream = createDraftStream();
     createTelegramDraftStream.mockReturnValue(draftStream);

extensions/telegram/src/bot-message-dispatch.ts

@@ -729,6 +729,7 @@ export const dispatchTelegramMessage = async ({
       }
       return { ...payload, replyToId: implicitQuoteReplyTargetId };
     };
+    let lastVisibleNonPreviewDeliveryAtMs: number | undefined;
     const sendPayload = async (payload: ReplyPayload) => {
       if (isDispatchSuperseded()) {
         return false;
@@ -742,6 +743,7 @@ export const dispatchTelegramMessage = async ({
       });
       if (result.delivered) {
         deliveryState.markDelivered();
+        lastVisibleNonPreviewDeliveryAtMs = Date.now();
       }
       return result.delivered;
     };
@@ -794,6 +796,7 @@ export const dispatchTelegramMessage = async ({
       markDelivered: () => {
         deliveryState.markDelivered();
       },
+      getLastVisibleNonPreviewDeliveryAtMs: () => lastVisibleNonPreviewDeliveryAtMs,
     });
 
     if (isDmTopic) {

extensions/telegram/src/lane-delivery-text-deliverer.ts

@@ -95,6 +95,10 @@ type CreateLaneTextDelivererParams = {
   log: (message: string) => void;
   markDelivered: () => void;
   now?: () => number;
+  // Force fresh final when a visible non-preview message has been delivered
+  // since the active preview was created, even if the preview is younger
+  // than the long-lived threshold (#76529).
+  getLastVisibleNonPreviewDeliveryAtMs?: () => number | undefined;
 };
 
 type DeliverLaneTextParams = {
@@ -204,10 +208,25 @@ export function createLaneTextDeliverer(params: CreateLaneTextDelivererParams) {
     params.retainPreviewOnCleanupByLane[laneName] = true;
   };
   const isMessagePreviewLane = (lane: DraftLaneState) => lane.stream != null;
-  const shouldUseFreshFinalForLane = (lane: DraftLaneState) =>
-    isMessagePreviewLane(lane) && isLongLivedPreview(lane.stream?.visibleSinceMs?.(), readNow());
+  const wasVisiblyOverwrittenSince = (visibleSinceMs: number | undefined): boolean => {
+    if (typeof visibleSinceMs !== "number") {
+      return false;
+    }
+    const lastNonPreviewAt = params.getLastVisibleNonPreviewDeliveryAtMs?.();
+    return typeof lastNonPreviewAt === "number" && lastNonPreviewAt > visibleSinceMs;
+  };
+  const shouldUseFreshFinalForLane = (lane: DraftLaneState) => {
+    if (!isMessagePreviewLane(lane)) {
+      return false;
+    }
+    const visibleSinceMs = lane.stream?.visibleSinceMs?.();
+    return (
+      isLongLivedPreview(visibleSinceMs, readNow()) || wasVisiblyOverwrittenSince(visibleSinceMs)
+    );
+  };
   const shouldUseFreshFinalForPreview = (lane: DraftLaneState, visibleSinceMs?: number) =>
-    isMessagePreviewLane(lane) && isLongLivedPreview(visibleSinceMs, readNow());
+    isMessagePreviewLane(lane) &&
+    (isLongLivedPreview(visibleSinceMs, readNow()) || wasVisiblyOverwrittenSince(visibleSinceMs));
   const clearActivePreviewAfterFreshFinal = async (lane: DraftLaneState, laneName: LaneName) => {
     try {
       await lane.stream?.clear();