@llblab/pi-telegram 0.43.1 → 0.44.0

package/lib/activity.ts

@@ -32,6 +32,7 @@ export interface TelegramActivityEnvelope {
   sequence: number;
   source: TelegramActivitySource;
   target?: TelegramActivityTarget;
+  replyToMessageId?: number;
   timestamp: number;
 }
 
@@ -422,8 +423,8 @@ export function createTelegramActivityBridgeRuntime(deps: {
     recordInputSource(source) {
       getRuntime()?.recordInputSource(source);
     },
-    onAgentStart(target) {
-      getRuntime()?.onAgentStart(target);
+    onAgentStart(target, replyToMessageId) {
+      getRuntime()?.onAgentStart(target, replyToMessageId);
     },
     onAssistantEvent(event) {
       getRuntime()?.onAssistantEvent(event);
@@ -492,7 +493,7 @@ export type TelegramAssistantStreamEvent =
 export interface TelegramActivityRuntime {
   onSessionStart?: () => void;
   recordInputSource: (source: TelegramActivityInputSource) => void;
-  onAgentStart: (activeTelegramTarget?: TelegramActivityTarget) => void;
+  onAgentStart: (activeTelegramTarget?: TelegramActivityTarget, replyToMessageId?: number) => void;
   onAssistantEvent: (event: TelegramAssistantStreamEvent) => void;
   onAssistantMessageEnd: (stopReason?: string) => void;
   onToolStart: (event: {
@@ -549,6 +550,7 @@ export function createTelegramActivityRuntime(deps: {
   let activityId: string | undefined;
   let activitySource: TelegramActivitySource = "unknown";
   let activityTarget: TelegramActivityTarget | undefined;
+  let activityReplyToMessageId: number | undefined;
   let sequence = 0;
   let pendingInputSource: TelegramActivityInputSource = "unknown";
   let pendingAssistantSegment: PendingAssistantSegment | undefined;
@@ -584,6 +586,7 @@ export function createTelegramActivityRuntime(deps: {
       sequence,
       source: activitySource,
       ...(activityTarget ? { target: activityTarget } : {}),
+      ...(activityReplyToMessageId !== undefined ? { replyToMessageId: activityReplyToMessageId } : {}),
       timestamp: now(),
     } as TelegramActivityEvent;
     try {
@@ -610,6 +613,7 @@ export function createTelegramActivityRuntime(deps: {
     activityId = undefined;
     activitySource = "unknown";
     activityTarget = undefined;
+    activityReplyToMessageId = undefined;
     sequence = 0;
     pendingAssistantSegment = undefined;
     compactionInProgress = false;
@@ -627,9 +631,10 @@ export function createTelegramActivityRuntime(deps: {
     recordInputSource(source) {
       pendingInputSource = source;
     },
-    onAgentStart(activeTelegramTarget) {
+    onAgentStart(activeTelegramTarget, replyToMessageId) {
       abandonCompaction();
       ensureActivity(activeTelegramTarget);
+      activityReplyToMessageId = activitySource === "telegram" ? replyToMessageId : undefined;
       emit({ type: "agent-start" });
     },
     onAssistantEvent(event) {
@@ -738,6 +743,63 @@ export function createTelegramActivityRuntime(deps: {
   };
 }
 
+// --- Ordered Bridge-Owned Publication ---
+
+export interface TelegramActivityPublicationReservation {
+  publish: (task: () => Promise<void>) => Promise<void>;
+  cancel: () => void;
+}
+
+export interface TelegramActivityPublicationRuntime {
+  enqueue: (task: () => Promise<void>) => Promise<void>;
+  reserve: () => TelegramActivityPublicationReservation;
+  reset: () => void;
+}
+
+export function createTelegramActivityPublicationRuntime(): TelegramActivityPublicationRuntime {
+  let generation = 0;
+  let tail = Promise.resolve();
+  const pending = new Set<() => void>();
+  const reserve = (): TelegramActivityPublicationReservation => {
+    const admittedGeneration = generation;
+    let state: "pending" | "published" | "cancelled" = "pending";
+    let resolve!: (task: (() => Promise<void>) | undefined) => void;
+    const ready = new Promise<(() => Promise<void>) | undefined>((accept) => { resolve = accept; });
+    const cancel = () => {
+      if (state !== "pending") return;
+      state = "cancelled";
+      pending.delete(cancel);
+      resolve(undefined);
+    };
+    pending.add(cancel);
+    const result = tail.then(async () => {
+      const task = await ready;
+      if (admittedGeneration === generation && task) await task();
+    });
+    tail = result.catch(() => {});
+    return {
+      publish(task) {
+        if (state === "cancelled") return result;
+        if (state === "published") return Promise.reject(new Error("Publication reservation already published."));
+        state = "published";
+        pending.delete(cancel);
+        resolve(task);
+        return result;
+      },
+      cancel,
+    };
+  };
+  return {
+    reserve,
+    enqueue: (task) => reserve().publish(task),
+    reset() {
+      generation += 1;
+      for (const cancel of pending) cancel();
+      tail = Promise.resolve();
+    },
+  };
+}
+
 // --- Public Assistant Output Projection ---
 
 export interface TelegramAssistantOutputRuntime {
@@ -747,7 +809,14 @@ export interface TelegramAssistantOutputRuntime {
   stop: () => void;
 }
 
+export interface TelegramAssistantOutputPreparation {
+  wait: () => Promise<void>;
+  settle: () => void;
+}
+
 export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(deps: {
+  prepareSend?: (event: TelegramAssistantSegmentEvent) => TelegramAssistantOutputPreparation | undefined;
+  enqueue?: TelegramActivityPublicationRuntime["enqueue"];
   captureAuthority?: () => TAuthority;
   isAuthorityActive?: (authority: TAuthority) => boolean;
   canDeliver: (event: TelegramAssistantSegmentEvent) => boolean;
@@ -785,7 +854,9 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
       admitted.add(key);
       const admittedGeneration = generation;
       const admittedAuthority = deps.captureAuthority?.();
-      tail = tail.then(async () => {
+      const preparation = deps.prepareSend?.(event);
+      const enqueue = deps.enqueue ?? ((task: () => Promise<void>) => tail.then(task));
+      tail = enqueue(async () => {
         const isAdmittedAuthorityActive = () =>
           running &&
           generation === admittedGeneration &&
@@ -794,6 +865,8 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
             deps.isAuthorityActive(admittedAuthority as TAuthority));
         if (!isAdmittedAuthorityActive() || !deps.canDeliver(event)) return;
         try {
+          if (preparation) await preparation.wait();
+          if (!isAdmittedAuthorityActive() || !deps.canDeliver(event)) return;
           await deps.send(
             event,
             admittedAuthority as TAuthority,
@@ -802,7 +875,7 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
         } catch (error) {
           deps.recordFailure?.(event, error);
         }
-      });
+      }).finally(() => preparation?.settle());
     },
     waitForIdle() {
       return tail;

package/lib/bindings.ts

@@ -353,6 +353,8 @@ export function createTelegramAssistantOutputBindingRuntime<
     typeof OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>
   >[0];
   waitForActivityIdle?: () => Promise<void>;
+  prepareTelegramPreview?: () => Activity.TelegramAssistantOutputPreparation | undefined;
+  enqueue?: Activity.TelegramActivityPublicationRuntime["enqueue"];
   recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }): TelegramAssistantOutputBindingRuntime<TTransportStamp> {
   const authority = Routing.createTelegramAssistantOutputAuthorityRuntime(
@@ -364,6 +366,8 @@ export function createTelegramAssistantOutputBindingRuntime<
     );
   const runtime = Activity.createTelegramAssistantOutputRuntime({
     ...authority,
+    enqueue: deps.enqueue,
+    prepareSend: (event) => event.source === "telegram" ? deps.prepareTelegramPreview?.() : undefined,
     async send(event, authority, isAuthorityActive) {
       await deps.waitForActivityIdle?.();
       if (!isAuthorityActive()) return;
@@ -390,7 +394,14 @@ type TelegramAssistantOutputAuthority<TTransportStamp> = ReturnType<
   Routing.TelegramAssistantOutputAuthorityRuntime<TTransportStamp>["captureAuthority"]
 >;
 
+export interface TelegramBridgePublicationRuntime {
+  enqueue: Activity.TelegramActivityPublicationRuntime["enqueue"];
+  reserve: Activity.TelegramActivityPublicationRuntime["reserve"];
+  capture: () => { target?: Queue.TelegramQueueTarget; isCurrent: () => boolean };
+}
+
 export interface TelegramActivityBindingRuntime {
+  publicationRuntime: TelegramBridgePublicationRuntime;
   activityRuntime: Activity.TelegramActivityRuntime;
   activityVerbosityRuntime: ActivityVerbosity.TelegramActivityVerbosityRuntime;
   assistantOutputRuntime: Activity.TelegramAssistantOutputRuntime;
@@ -403,7 +414,7 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     Parameters<
       typeof createTelegramAssistantOutputBindingRuntime<TTransportStamp>
     >[0],
-    "waitForActivityIdle"
+    "waitForActivityIdle" | "enqueue"
   >;
   activityVerbosity: Omit<
     Parameters<
@@ -411,19 +422,19 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
         TelegramAssistantOutputAuthority<TTransportStamp>
       >
     >[0],
-    "captureAuthority" | "isAuthorityActive" | "recordFailure"
+    "captureAuthority" | "isAuthorityActive" | "recordFailure" | "enqueue"
   >;
 }): TelegramActivityBindingRuntime {
-  const activityVerbosityBinding =
-    ActivityVerbosity.createTelegramActivityVerbosityBinding();
+  const publication = Activity.createTelegramActivityPublicationRuntime();
   const assistantOutputBinding =
     createTelegramAssistantOutputBindingRuntime({
       ...deps.assistantOutput,
-      waitForActivityIdle: activityVerbosityBinding.waitForIdle,
+      enqueue: publication.enqueue,
     });
   const activityVerbosityRuntime =
     ActivityVerbosity.createTelegramActivityVerbosityRuntime({
       ...deps.activityVerbosity,
+      enqueue: publication.enqueue,
       captureAuthority: assistantOutputBinding.authority.captureAuthority,
       isAuthorityActive: assistantOutputBinding.authority.isAuthorityActive,
       recordFailure(operation, event, error) {
@@ -434,7 +445,6 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
         });
       },
     });
-  activityVerbosityBinding.bind(activityVerbosityRuntime);
   const activityRuntime = Activity.createTelegramActivityBridgeRuntime({
     generation: deps.generation,
     observeEvent(event) {
@@ -450,9 +460,30 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     },
   });
   return {
-    activityRuntime,
+    activityRuntime: {
+      ...activityRuntime,
+      onSessionStart() {
+        publication.reset();
+        activityRuntime.onSessionStart?.();
+      },
+      onSessionShutdown() {
+        publication.reset();
+        activityRuntime.onSessionShutdown();
+      },
+    },
     activityVerbosityRuntime,
     assistantOutputRuntime: assistantOutputBinding.runtime,
+    publicationRuntime: {
+      enqueue: publication.enqueue,
+      reserve: publication.reserve,
+      capture() {
+        const authority = assistantOutputBinding.authority.captureAuthority();
+        return {
+          target: authority.target ? { ...authority.target } : undefined,
+          isCurrent: () => assistantOutputBinding.authority.isAuthorityActive(authority),
+        };
+      },
+    },
   };
 }
 
@@ -680,6 +711,7 @@ export function registerTelegramCommandsAndTools({
 
 interface TelegramLifecycleBindingDeps {
   pi: Pi.ExtensionAPI;
+  publicationRuntime: TelegramBridgePublicationRuntime;
   activityRuntime: Activity.TelegramActivityRuntime;
   activityVerbosityRuntime?: ActivityVerbosity.TelegramActivityVerbosityRuntime;
   assistantOutputRuntime: Pick<
@@ -748,6 +780,7 @@ interface TelegramLifecycleBindingDeps {
       Keyboard.TelegramInlineKeyboardMarkup
     >["sendGuestReply"]
   >;
+  preparePreviewDelivery?: Queue.TelegramAgentEndRuntimeDeps<Queue.PendingTelegramTurn>["preparePreviewDelivery"];
   finalizeMarkdownPreview: Queue.TelegramAgentEndHookRuntimeDeps<
     Queue.PendingTelegramTurn,
     Pi.ExtensionContext,
@@ -770,6 +803,7 @@ interface TelegramLifecycleBindingDeps {
 
 export function registerTelegramLifecycleRuntimeHooks({
   pi,
+  publicationRuntime,
   activityRuntime,
   activityVerbosityRuntime,
   assistantOutputRuntime,
@@ -798,6 +832,7 @@ export function registerTelegramLifecycleRuntimeHooks({
   answerGuestQuery,
   deleteMessage,
   sendGuestReply,
+  preparePreviewDelivery,
   finalizeMarkdownPreview,
   proactivePushTargetGetter,
   getAssistantRenderingMode,
@@ -936,24 +971,19 @@ export function registerTelegramLifecycleRuntimeHooks({
       { replyToPrompt: false },
     );
   };
-  let activeTurnDeliveryTail = Promise.resolve();
-  const scheduleActiveTurnDelivery = (task: () => Promise<void>): void => {
-    const previous = activeTurnDeliveryTail;
-    activeTurnDeliveryTail = (async () => {
-      await previous;
-      await new Promise<void>((resolve) => {
-        const timer = setTimeout(resolve, 0);
-        timer.unref?.();
-      });
-      await task();
-    })().catch((error) => {
-      recordRuntimeEvent("delivery", error, {
-        phase: "agent-end-background-delivery",
-      });
-    });
+  let pendingFinalPublication: {
+    turn: Queue.PendingTelegramTurn;
+    reservation: Activity.TelegramActivityPublicationReservation;
+  } | undefined;
+  const cancelPendingFinalPublication = (): void => {
+    pendingFinalPublication?.reservation.cancel();
+    pendingFinalPublication = undefined;
   };
-  const waitForActiveTurnDelivery = async (): Promise<void> => {
-    await activeTurnDeliveryTail;
+  const recordPublicationFailure = (error: unknown): void => {
+    recordRuntimeEvent("delivery", error, { phase: "agent-end-background-delivery" });
+  };
+  const scheduleActiveTurnDelivery = (task: () => Promise<void>): void => {
+    void publicationRuntime.enqueue(task).catch(recordPublicationFailure);
   };
   const agentLifecycleHooks = Queue.createTelegramAgentLifecycleHooks<
     Queue.PendingTelegramTurn,
@@ -989,14 +1019,23 @@ export function registerTelegramLifecycleRuntimeHooks({
     isSessionActive: isSessionContextActive,
     isTurnTransportActive,
     waitForTypingIdle: typing.waitForIdle,
-    async waitForActivityIdle() {
-      await activityVerbosityRuntime?.waitForIdle();
-      await assistantOutputRuntime.waitForIdle();
-    },
     dispatchNextQueuedTelegramTurn,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
     scheduleActiveTurnDelivery,
+    reserveActiveTurnDelivery() {
+      const pending = pendingFinalPublication;
+      pendingFinalPublication = undefined;
+      const matches = pending?.turn === activeTurnRuntime.get();
+      if (!matches) pending?.reservation.cancel();
+      const reservation = matches && pending ? pending.reservation : publicationRuntime.reserve();
+      return {
+        schedule: (task) => { void reservation.publish(task).catch(recordPublicationFailure); },
+        cancel: reservation.cancel,
+      };
+    },
+    preparePreviewDelivery,
+    preparePreviewClear: previewRuntime.prepareClear,
     clearPreview: previewRuntime.clear,
     setPreviewPendingText: previewRuntime.setPendingText,
     finalizeMarkdownPreview,
@@ -1018,6 +1057,7 @@ export function registerTelegramLifecycleRuntimeHooks({
   Lifecycle.setResetTransportReplyDedup(Replies.resetTransportReplyDedup);
   const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
     agentLifecycleHooks.onAgentStart,
+    scheduleActiveTurnDelivery,
   );
   let uiPromptActive = false;
   const startAgentActivityTypingLoop = (ctx: Pi.ExtensionContext): boolean => {
@@ -1038,25 +1078,24 @@ export function registerTelegramLifecycleRuntimeHooks({
   };
   let observedAutomaticCompaction = false;
   let agentWorkActive = false;
-  let terminalAssistantMessagePendingDelivery = false;
-  const deferredAutomaticCompactionNotices: string[] = [];
-  const sendCompactionNotice = async (text: string): Promise<void> => {
+  const prepareCompactionNotice = (text: string, ctx: Pi.ExtensionContext): (() => Promise<void>) => {
+    const authority = publicationRuntime.capture();
     const turn = activeTurnRuntime.get();
-    const target = turn?.target ?? proactivePushTargetGetter?.();
-    if (!target) return;
-    try {
-      await sendMarkdownReply(target.chatId, turn?.replyToMessageId, text, {
-        target,
-      });
-    } catch (error) {
-      recordRuntimeEvent("delivery", error, {
-        phase: "compaction-notice",
-      });
-    }
+    const selectedTarget = turn?.target ?? authority.target;
+    const target = selectedTarget ? { ...selectedTarget } : undefined;
+    const replyToMessageId = turn?.replyToMessageId;
+    return async () => {
+      if (!target || !isSessionContextActive(ctx) || !authority.isCurrent()) return;
+      if (turn && isTurnTransportActive?.(turn) === false) return;
+      try {
+        await sendMarkdownReply(target.chatId, replyToMessageId, text, { target });
+      } catch (error) {
+        recordRuntimeEvent("delivery", error, { phase: "compaction-notice" });
+      }
+    };
   };
-  const flushDeferredAutomaticCompactionNotices = async (): Promise<void> => {
-    const notices = deferredAutomaticCompactionNotices.splice(0);
-    for (const notice of notices) await sendCompactionNotice(notice);
+  const sendCompactionNotice = (text: string, ctx: Pi.ExtensionContext): void => {
+    scheduleActiveTurnDelivery(prepareCompactionNotice(text, ctx));
   };
   const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
     isContextActive: isSessionContextActive,
@@ -1070,7 +1109,6 @@ export function registerTelegramLifecycleRuntimeHooks({
     recordRuntimeEvent,
     onCompactionAbandoned: () => {
       observedAutomaticCompaction = false;
-      deferredAutomaticCompactionNotices.length = 0;
       activityRuntime.onCompactionAbandoned();
     },
   });
@@ -1091,6 +1129,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.recordInputSource(event.source ?? "unknown");
     },
     async onSessionStart(event, ctx) {
+      cancelPendingFinalPublication();
       previewRuntime.invalidate();
       assistantOutputRuntime.start();
       activityRuntime.onSessionStart?.();
@@ -1106,9 +1145,8 @@ export function registerTelegramLifecycleRuntimeHooks({
       assistantOutputRuntime.stop();
       observedAutomaticCompaction = false;
       agentWorkActive = false;
-      terminalAssistantMessagePendingDelivery = false;
+      cancelPendingFinalPublication();
       uiPromptActive = false;
-      deferredAutomaticCompactionNotices.length = 0;
       compactionObserver.onSessionShutdown();
       if (event.reason === "quit" && disconnectOnQuit) {
         try {
@@ -1129,19 +1167,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       if (shouldNotify) observedAutomaticCompaction = true;
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
-      if (shouldNotify) {
-        if (terminalAssistantMessagePendingDelivery) {
-          deferredAutomaticCompactionNotices.push(
-            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
-          );
-        } else {
-          await waitForActiveTurnDelivery();
-          if (!isSessionContextActive(ctx)) return;
-          await sendCompactionNotice(
-            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
-          );
-        }
-      }
+      if (shouldNotify) sendCompactionNotice(Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN, ctx);
     },
     async onSessionCompact(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1149,40 +1175,26 @@ export function registerTelegramLifecycleRuntimeHooks({
       compactionObserver.onSessionCompact(event, ctx);
       if (observedAutomaticCompaction) {
         observedAutomaticCompaction = false;
-        if (deferredAutomaticCompactionNotices.length > 0) {
-          deferredAutomaticCompactionNotices.push(
-            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
-          );
-        } else {
-          await sendCompactionNotice(
-            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
-          );
-        }
+        sendCompactionNotice(Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN, ctx);
       }
     },
     async onSessionCompactFailed(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       const shouldNotify = observedAutomaticCompaction;
-      const deferredNotices = deferredAutomaticCompactionNotices.splice(0);
-      const shouldDefer =
-        deferredNotices.length > 0 || terminalAssistantMessagePendingDelivery;
       compactionObserver.onSessionCompactFailed(event, ctx);
       if (!shouldNotify) return;
       const notice = event.aborted
         ? "**⚠️ Compaction cancelled.**"
         : "**⚠️ Compaction failed.**";
-      if (shouldDefer) {
-        deferredAutomaticCompactionNotices.push(...deferredNotices, notice);
-      } else {
-        await sendCompactionNotice(notice);
-      }
+      sendCompactionNotice(notice, ctx);
     },
     async onAgentStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       agentWorkActive = true;
-      terminalAssistantMessagePendingDelivery = false;
+      cancelPendingFinalPublication();
       await agentStartWithDedupReset(event, ctx);
-      activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
+      const turn = activeTurnRuntime.get();
+      activityRuntime.onAgentStart(turn?.target, turn?.replyToMessageId);
       startAgentActivityTypingLoop(ctx);
     },
     async onToolExecutionStart(event, ctx) {
@@ -1228,13 +1240,16 @@ export function registerTelegramLifecycleRuntimeHooks({
     onMessageEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       if (event.message.role === "assistant") {
+        previewRuntime.seal();
         activityRuntime.onAssistantMessageEnd(event.message.stopReason);
       }
-      terminalAssistantMessagePendingDelivery =
-        event.message.role === "assistant" &&
-        event.message.stopReason !== "toolUse" &&
-        event.message.stopReason !== "error" &&
-        event.message.stopReason !== "aborted";
+      if (event.message.role !== "assistant" || event.message.stopReason === "toolUse" || event.message.stopReason === "aborted") return;
+      const turn = activeTurnRuntime.get();
+      if (!turn || turn.guestQueryId || pendingFinalPublication?.turn === turn) return;
+      cancelPendingFinalPublication();
+      const assistant = Replies.extractLatestAssistantMessageText([event.message]);
+      if (!assistant.text && assistant.stopReason !== "error" && turn.queuedAttachments.length === 0) return;
+      pendingFinalPublication = { turn, reservation: publicationRuntime.reserve() };
     },
     onUiPromptStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1254,18 +1269,22 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      if (pendingFinalPublication && pendingFinalPublication.turn !== activeTurnRuntime.get()) {
+        cancelPendingFinalPublication();
+        return;
+      }
       activityRuntime.onAgentEnd();
       await agentLifecycleHooks.onAgentEnd(event, ctx);
     },
     async onAgentSettled(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
-      await agentLifecycleHooks.onAgentSettled(event, ctx);
-      if (deferredAutomaticCompactionNotices.length > 0) {
-        await waitForActiveTurnDelivery();
-        if (!isSessionContextActive(ctx)) return;
-        await flushDeferredAutomaticCompactionNotices();
+      const pending = pendingFinalPublication;
+      try {
+        await agentLifecycleHooks.onAgentSettled(event, ctx);
+      } finally {
+        if (pendingFinalPublication === pending) cancelPendingFinalPublication();
       }
-      terminalAssistantMessagePendingDelivery = false;
+      if (!isSessionContextActive(ctx)) return;
       agentWorkActive = false;
       activityRuntime.onAgentSettled();
       modelContextAvailabilityRuntime.reconcile();

package/lib/config.ts

@@ -744,7 +744,7 @@ export function createTelegramDraftPreviewsChecker(
       config.assistant?.draftPreviews ??
       config.draftPreviews ??
       config.richDraftPreviews ??
-      false
+      true
     );
   };
 }

package/lib/delivery.ts

@@ -10,7 +10,7 @@ import {
   type TelegramInlineKeyboardMarkup,
 } from "./keyboard.ts";
 import {
-  buildTelegramReplyParameters,
+  withTelegramReplyParameters,
   renderTelegramMessage,
 } from "./replies.ts";
 import {
@@ -724,23 +724,23 @@ export function createTelegramBridgeDeliveryRuntime(
     },
     async sendChunk(target, chunk, options) {
       assertTransportActive();
-      const replyParameters = buildTelegramReplyParameters(
-        target.chatId,
-        options.replyToMessageId,
-        target,
-      );
-      const body = {
-        chat_id: target.chatId,
-        text: chunk.text,
-        ...(chunk.parseMode === "html" ? { parse_mode: "HTML" as const } : {}),
-        ...getTelegramTargetThreadParams(target),
-        ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-        ...(options.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
-      };
-      const sent = await deps.api.sendMessage(
-        target.threadId === undefined
-          ? markTelegramBusAggregateDelivery(body)
-          : body,
+      const sent = await withTelegramReplyParameters(
+        target.chatId, options.replyToMessageId, target,
+        (replyParameters) => {
+          const body = {
+            chat_id: target.chatId,
+            text: chunk.text,
+            ...(chunk.parseMode === "html" ? { parse_mode: "HTML" as const } : {}),
+            ...getTelegramTargetThreadParams(target),
+            ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+            ...(options.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
+          };
+          return deps.api.sendMessage(
+            target.threadId === undefined
+              ? markTelegramBusAggregateDelivery(body)
+              : body,
+          );
+        },
       );
       assertTransportActive();
       deps.recordOwnership({

package/lib/lifecycle.ts

@@ -37,9 +37,15 @@ export function setResetTransportReplyDedup(fn: () => void): void {
 
 export function createAgentStartDedupHook(
   inner: (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>,
+  schedulePublication?: (task: () => Promise<void>) => void,
 ): (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void> {
   return async (event, ctx) => {
-    if (resetTransportReplyDedupFn) resetTransportReplyDedupFn();
+    const reset = resetTransportReplyDedupFn;
+    if (reset) {
+      // A new turn must not erase the anchor of a final still ahead in the FIFO.
+      if (schedulePublication) schedulePublication(async () => { reset(); });
+      else reset();
+    }
     return inner(event, ctx);
   };
 }
@@ -450,8 +456,10 @@ export function createTelegramCompactionObserverRuntime<TContext>(
   const setTimer = deps.setTimer ?? setTimeout;
   const clearTimer = deps.clearTimer ?? clearTimeout;
   let fallbackTimer: TelegramLifecycleTimer | undefined;
+  let observationGeneration = 0;
   let typingStartedByObserver = false;
   const clearFallbackTimer = (): void => {
+    observationGeneration += 1;
     if (!fallbackTimer) return;
     clearTimer(fallbackTimer);
     fallbackTimer = undefined;
@@ -470,7 +478,10 @@ export function createTelegramCompactionObserverRuntime<TContext>(
         !!deps.startTypingLoop && typingStartResult !== false;
       deps.updateStatus(ctx);
       clearFallbackTimer();
+      const admittedGeneration = observationGeneration;
       fallbackTimer = setTimer(() => {
+        if (observationGeneration !== admittedGeneration) return;
+        observationGeneration += 1;
         fallbackTimer = undefined;
         if (deps.isContextActive && !deps.isContextActive(ctx)) return;
         deps.setCompactionInProgress(false);
@@ -487,8 +498,8 @@ export function createTelegramCompactionObserverRuntime<TContext>(
       unrefTelegramLifecycleTimer(fallbackTimer);
     },
     onSessionCompact: (_event, ctx) => {
-      clearFallbackTimer();
       if (deps.isContextActive && !deps.isContextActive(ctx)) return;
+      clearFallbackTimer();
       deps.setCompactionInProgress(false);
       if (typingStartedByObserver) deps.stopTypingLoop?.();
       typingStartedByObserver = false;
@@ -496,8 +507,8 @@ export function createTelegramCompactionObserverRuntime<TContext>(
       requestDispatch();
     },
     onSessionCompactFailed: (_event, ctx) => {
-      clearFallbackTimer();
       if (deps.isContextActive && !deps.isContextActive(ctx)) return;
+      clearFallbackTimer();
       deps.setCompactionInProgress(false);
       if (typingStartedByObserver) deps.stopTypingLoop?.();
       typingStartedByObserver = false;