@llblab/pi-kit 0.21.0 → 0.21.2

package/node_modules/@llblab/pi-telegram/lib/bindings.ts

@@ -52,6 +52,7 @@ export interface TelegramQueueBindingRuntime<TContext> {
   mutation: Queue.TelegramQueueMutationController<TContext>;
   dispatchNext: (ctx: TContext) => void;
   requestNextDispatchAnnouncement: () => void;
+  cancelNextDispatchAnnouncement: () => void;
   watchdog: Queue.TelegramQueueDispatchWatchdogRuntime<TContext>;
 }
 
@@ -96,6 +97,9 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
   updateStatus: (ctx: TContext, error?: string) => void;
   sendTextReply: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendTextReply"];
   sendUserMessage: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendUserMessage"];
+  reconcileNextDispatchAnnouncementReplyOwnership?: (
+    item: Queue.PendingTelegramTurn,
+  ) => void;
   recordRuntimeEvent?: TelegramRuntimeEventRecorder;
 }): TelegramQueueBindingRuntime<TContext> {
   const settleDiscardedItems = (
@@ -159,6 +163,8 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
     },
     updateStatus: deps.updateStatus,
     sendTextReply: deps.sendTextReply,
+    reconcileNextDispatchAnnouncementReplyOwnership:
+      deps.reconcileNextDispatchAnnouncementReplyOwnership,
     recordRuntimeEvent: deps.recordRuntimeEvent,
     ...deps.promptDispatch,
     sendUserMessage: deps.sendUserMessage,
@@ -167,6 +173,7 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
     mutation,
     dispatchNext: dispatch.dispatchNext,
     requestNextDispatchAnnouncement: dispatch.requestNextDispatchAnnouncement,
+    cancelNextDispatchAnnouncement: dispatch.cancelNextDispatchAnnouncement,
     watchdog: Queue.createTelegramQueueDispatchWatchdogRuntime({
       hasQueuedItems: deps.store.hasQueuedItems,
       dispatchNextQueuedTelegramTurn: dispatch.dispatchNext,

package/node_modules/@llblab/pi-telegram/lib/bus-follower.ts

@@ -11,7 +11,11 @@ import { basename } from "node:path";
 import * as Sync from "./sync.ts";
 import * as Threads from "./threads.ts";
 import { parseTelegramUpdateJournalQueueOwner, type TelegramUpdateJournalStoreOptions } from "./journal.ts";
-import type { TelegramLockEntry, TelegramLockState } from "./locks.ts";
+import {
+  TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS,
+  type TelegramLockEntry,
+  type TelegramLockState,
+} from "./locks.ts";
 import type {
   TelegramQueueHandoffPayload,
   TelegramQueueHandoffStageResult,
@@ -60,6 +64,8 @@ export const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2_500;
 export const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_WAIT_MS = 30_000;
+export const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS =
+  TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS =
   TELEGRAM_BUS_REGISTRATION_RETRY.attempts;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS =
@@ -301,6 +307,7 @@ export interface TelegramBusFollowerRegistrationRuntimeDeps<
   registrationRetryAttempts?: number;
   registrationRetryDelayMs?: number;
   heartbeatMs?: number;
+  heartbeatTimeoutMs?: number;
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -1619,6 +1626,10 @@ export function createTelegramBusFollowerRegistrationRuntime<
   const getNowMs = deps.getNowMs ?? Date.now;
   const getPid = deps.getPid ?? (() => process.pid);
   const heartbeatMs = deps.heartbeatMs ?? 1000;
+  const heartbeatTimeoutMs =
+    deps.heartbeatTimeoutMs ??
+    deps.timeoutMs ??
+    TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS;
   const registrationTimeoutMs =
     deps.registrationTimeoutMs ?? deps.timeoutMs ?? 30000;
   const registrationRetryAttempts =
@@ -1679,7 +1690,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
     try {
       const response = await sendTelegramBusLocalEnvelope({
         socketPath: leaderSocketPath,
-        timeoutMs: deps.timeoutMs,
+        timeoutMs: heartbeatTimeoutMs,
         retry: getTelegramBusTransportRetryPolicy({
           endpoint: leaderSocketPath,
           operation: "operation",

package/node_modules/@llblab/pi-telegram/lib/commands.ts

@@ -711,6 +711,7 @@ export interface TelegramCommandActionDeps<TMessage, TContext> {
 export interface TelegramStopCommandDeps {
   hasAbortHandler: () => boolean;
   clearPendingModelSwitch: () => void;
+  cancelNextTransitionAnnouncements?: () => void;
   clearQueuedTelegramItems: () => number;
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   abortCurrentTurn: () => void;
@@ -1146,6 +1147,8 @@ export interface TelegramCommandRuntimeDeps<
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestNextDispatchAnnouncement?: () => void;
+  markActiveTurnNextAbortAnnouncement?: () => boolean;
+  cancelNextTransitionAnnouncements?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -1352,6 +1355,7 @@ export async function handleTelegramStopCommand(
   deps: TelegramStopCommandDeps,
 ): Promise<void> {
   deps.clearPendingModelSwitch();
+  deps.cancelNextTransitionAnnouncements?.();
   const clearedCount = deps.clearQueuedTelegramItems();
   deps.setFoldQueuedPromptsIntoHistory(false);
   if (!deps.hasAbortHandler()) {
@@ -1385,6 +1389,7 @@ export async function handleTelegramAbortCommand(deps: {
   hasAbortHandler: () => boolean;
   hasActiveTelegramTurn: () => boolean;
   clearPendingModelSwitch: () => void;
+  cancelNextTransitionAnnouncements?: () => void;
   abortCurrentTurn: () => void;
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   updateStatus: () => void;
@@ -1394,6 +1399,7 @@ export async function handleTelegramAbortCommand(deps: {
   ) => Promise<void>;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
+  deps.cancelNextTransitionAnnouncements?.();
   if (!deps.hasAbortHandler()) {
     await deps.sendTextReply(
       formatTelegramInformationHeading("💤", "No active turn."),
@@ -1418,6 +1424,7 @@ export async function handleTelegramNextCommand(deps: {
   abortCurrentTurn: () => void;
   dispatchNextQueuedTurn: () => void;
   requestNextDispatchAnnouncement?: () => void;
+  markActiveTurnNextAbortAnnouncement?: () => boolean;
   clearFoldForDispatch: () => void;
   updateStatus: () => void;
   sendTextReply: (
@@ -1439,6 +1446,7 @@ export async function handleTelegramNextCommand(deps: {
   if (!deps.isIdle() && deps.hasAbortHandler()) {
     deps.clearFoldForDispatch();
     deps.requestNextDispatchAnnouncement?.();
+    deps.markActiveTurnNextAbortAnnouncement?.();
     deps.abortCurrentTurn();
     deps.updateStatus();
     return;
@@ -1880,6 +1888,11 @@ export function createTelegramCommandHandlerTargetRuntime<
     updateStatus: deps.updateStatus,
     isContextActive: deps.isContextActive,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+    markActiveTurnNextAbortAnnouncement:
+      deps.markActiveTurnNextAbortAnnouncement,
+    cancelNextTransitionAnnouncements:
+      deps.cancelNextTransitionAnnouncements,
     startTypingLoop: deps.startTypingLoop,
     stopTypingLoop: deps.stopTypingLoop,
     enqueueContinueTurn: deps.enqueueContinueTurn,
@@ -2037,6 +2050,8 @@ async function handleTelegramCommandRuntime<
         await handleTelegramStopCommand({
           hasAbortHandler: deps.hasAbortHandler,
           clearPendingModelSwitch: deps.clearPendingModelSwitch,
+          cancelNextTransitionAnnouncements:
+            deps.cancelNextTransitionAnnouncements,
           clearQueuedTelegramItems: () =>
             deps.clearQueuedTelegramItems(commandCtx),
           setFoldQueuedPromptsIntoHistory: deps.setFoldQueuedPromptsIntoHistory,
@@ -2113,6 +2128,8 @@ async function handleTelegramCommandRuntime<
           hasAbortHandler: deps.hasAbortHandler,
           hasActiveTelegramTurn: deps.hasActiveTelegramTurn,
           clearPendingModelSwitch: deps.clearPendingModelSwitch,
+          cancelNextTransitionAnnouncements:
+            deps.cancelNextTransitionAnnouncements,
           abortCurrentTurn: deps.abortCurrentTurn,
           setFoldQueuedPromptsIntoHistory: deps.setFoldQueuedPromptsIntoHistory,
           updateStatus: updateStatusFor(commandCtx),
@@ -2129,6 +2146,8 @@ async function handleTelegramCommandRuntime<
           dispatchNextQueuedTurn: () =>
             deps.dispatchNextQueuedTelegramTurn(commandCtx),
           requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+          markActiveTurnNextAbortAnnouncement:
+            deps.markActiveTurnNextAbortAnnouncement,
           clearFoldForDispatch: () =>
             deps.setFoldQueuedPromptsIntoHistory(false),
           updateStatus: updateStatusFor(commandCtx),

package/node_modules/@llblab/pi-telegram/lib/extension.ts

@@ -820,6 +820,7 @@ export default function (pi: Pi.ExtensionAPI) {
     mutation: queueMutationRuntime,
     dispatchNext: dispatchNextQueuedTelegramTurn,
     requestNextDispatchAnnouncement,
+    cancelNextDispatchAnnouncement,
     watchdog: queueDispatchWatchdogRuntime,
   } = Bindings.createTelegramQueueBindingRuntime({
     store: telegramQueueStore,
@@ -835,6 +836,13 @@ export default function (pi: Pi.ExtensionAPI) {
     updateStatus,
     sendTextReply,
     sendUserMessage,
+    reconcileNextDispatchAnnouncementReplyOwnership(item) {
+      Replies.preserveTransportReplyDedupOnNextReset(
+        item.chatId,
+        item.replyToMessageId,
+        item.target,
+      );
+    },
     recordRuntimeEvent,
   });
   const { finalizeMarkdownPreview, preparePreviewDelivery } =
@@ -1093,6 +1101,7 @@ export default function (pi: Pi.ExtensionAPI) {
     isContextActive: telegramSessionContextStore.isCurrent,
     dispatchNextQueuedTelegramTurn,
     requestNextDispatchAnnouncement,
+    cancelNextDispatchAnnouncement,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
     hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,

package/node_modules/@llblab/pi-telegram/lib/queue.ts

@@ -126,6 +126,8 @@ export interface PendingTelegramTurn extends TelegramQueueItemBase {
   historyText: string;
   priorityEmoji?: string;
   reactionSuppressionEmoji?: string;
+  /** Emit the explicit aborted-turn notice when /next settles this active turn. */
+  announceNextAbortOnEnd?: boolean;
 
   /** Turn should preferably be delivered as voice (mirror mode + user sent voice) */
   voiceReplyPreferred?: boolean;
@@ -235,6 +237,8 @@ export interface TelegramActiveTurnStore<
   has: () => boolean;
   set: (turn: TTurn) => void;
   clear: () => void;
+  markNextAbortAnnouncement: () => boolean;
+  clearNextAbortAnnouncement: () => boolean;
   getChatId: () => number | undefined;
   getTarget: () => TelegramQueueTarget | undefined;
   getReplyToMessageId: () => number | undefined;
@@ -461,6 +465,16 @@ export function createTelegramActiveTurnStore<
     clear: () => {
       activeTurn = undefined;
     },
+    markNextAbortAnnouncement: () => {
+      if (!activeTurn) return false;
+      activeTurn.announceNextAbortOnEnd = true;
+      return true;
+    },
+    clearNextAbortAnnouncement: () => {
+      if (!activeTurn?.announceNextAbortOnEnd) return false;
+      delete activeTurn.announceNextAbortOnEnd;
+      return true;
+    },
     getChatId: () => activeTurn?.chatId,
     getTarget: () =>
       activeTurn?.target ? { ...activeTurn.target } : undefined,
@@ -1488,6 +1502,7 @@ export interface TelegramAgentEndPlan {
   kind: "no-turn" | "aborted" | "error" | "text" | "attachments-only" | "empty";
   shouldClearPreview: boolean;
   shouldDispatchNext: boolean;
+  shouldSendAbortMessage: boolean;
   shouldSendErrorMessage: boolean;
   shouldSendAttachmentNotice: boolean;
 }
@@ -1680,6 +1695,7 @@ export function buildTelegramAgentEndPlan(options: {
   hasFinalText: boolean;
   hasQueuedAttachments: boolean;
   foldQueuedPromptsIntoHistory: boolean;
+  announceNextAbortOnEnd?: boolean;
 }): TelegramAgentEndPlan {
   const shouldDispatchNext = shouldDispatchAfterTelegramAgentEnd({
     hasTurn: options.hasTurn,
@@ -1691,6 +1707,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "no-turn",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1700,6 +1717,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "aborted",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: options.announceNextAbortOnEnd === true,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1709,6 +1727,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "error",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: true,
       shouldSendAttachmentNotice: false,
     };
@@ -1718,6 +1737,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "text",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1727,6 +1747,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "attachments-only",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: true,
     };
@@ -1735,6 +1756,7 @@ export function buildTelegramAgentEndPlan(options: {
     kind: "empty",
     shouldClearPreview: true,
     shouldDispatchNext,
+    shouldSendAbortMessage: false,
     shouldSendErrorMessage: false,
     shouldSendAttachmentNotice: false,
   };
@@ -1891,6 +1913,7 @@ export async function handleTelegramAgentEndRuntime<
     hasFinalText: !!finalText || hasOutboundArtifacts,
     hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
     foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
+    announceNextAbortOnEnd: turn?.announceNextAbortOnEnd === true,
   });
   if (!turn) {
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
@@ -2017,22 +2040,29 @@ export async function handleTelegramAgentEndRuntime<
       await clearTurnPreview();
       if (!isDeliveryActive()) return;
     }
-    if (endPlan.shouldSendErrorMessage) {
+    if (endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage) {
       const errorMessage = assistant.errorMessage ||
         "Telegram bridge: Pi failed while processing the request.";
-      const isOperationAborted = errorMessage.trim().replace(/\.$/, "") ===
-        "This operation was aborted";
-      await deps.sendTextReply(
-        turn.chatId,
-        turn.replyToMessageId,
-        isOperationAborted
-          ? "<b>⏹️ This operation was aborted.</b>"
-          : errorMessage,
-        {
-          target: turn.target,
-          ...(isOperationAborted ? { parseMode: "HTML" as const } : {}),
-        },
-      );
+      const isOperationAborted = endPlan.shouldSendAbortMessage ||
+        errorMessage.trim().replace(/\.$/, "") === "This operation was aborted";
+      try {
+        await deps.sendTextReply(
+          turn.chatId,
+          turn.replyToMessageId,
+          isOperationAborted
+            ? "<b>⏹️ This operation was aborted.</b>"
+            : errorMessage,
+          {
+            target: turn.target,
+            ...(isOperationAborted ? { parseMode: "HTML" as const } : {}),
+          },
+        );
+      } catch (error) {
+        if (!isOperationAborted) throw error;
+        deps.recordRuntimeEvent?.("dispatch", error, {
+          phase: "next-abort-announcement",
+        });
+      }
       if (!isDeliveryActive()) return;
       if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
       return;
@@ -2180,7 +2210,7 @@ export async function handleTelegramAgentEndRuntime<
   };
   if (
     deps.scheduleActiveTurnDelivery &&
-    (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)
+    (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)
   ) {
     deps.scheduleActiveTurnDelivery(deliverActiveTurn);
     return;
@@ -3092,6 +3122,9 @@ export interface TelegramQueueDispatchControllerDeps<
   ) => boolean;
   sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
   onPromptDispatchFailure: (ctx: TContext, message: string) => void;
+  reconcileNextDispatchAnnouncementReplyOwnership?: (
+    item: PendingTelegramTurn,
+  ) => void;
   isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
   hasPendingInboundQueueMutationForItem?: (
     item: TelegramQueueItem<TContext>,
@@ -3107,6 +3140,7 @@ export interface TelegramQueueDispatchControllerDeps<
 export interface TelegramQueueDispatchController<TContext = unknown> {
   dispatchNext: (ctx: TContext) => void;
   requestNextDispatchAnnouncement: () => void;
+  cancelNextDispatchAnnouncement: () => void;
 }
 
 export function executeTelegramQueueDispatchPlan<TContext = unknown>(
@@ -3161,6 +3195,8 @@ export function createTelegramQueueDispatchRuntime<TContext = unknown>(
     commitPromptDispatch: deps.commitPromptDispatch,
     sendUserMessage: deps.sendUserMessage,
     onPromptDispatchFailure: deps.onPromptDispatchFailure,
+    reconcileNextDispatchAnnouncementReplyOwnership:
+      deps.reconcileNextDispatchAnnouncementReplyOwnership,
     isQueueItemTransportActive: deps.isQueueItemTransportActive,
     hasPendingInboundQueueMutationForItem:
       deps.hasPendingInboundQueueMutationForItem,
@@ -3176,12 +3212,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
 ): TelegramQueueDispatchController<TContext> {
   let controlDispatchPending = false;
   let nextDispatchAnnouncementRequested = false;
+  let nextDispatchAnnouncementGeneration = 0;
   let nextDispatchAnnouncementAnchor: TelegramQueueItem<TContext> | undefined;
   const controller: TelegramQueueDispatchController<TContext> = {
     requestNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
       nextDispatchAnnouncementRequested = true;
       nextDispatchAnnouncementAnchor = undefined;
     },
+    cancelNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
+      nextDispatchAnnouncementRequested = false;
+      nextDispatchAnnouncementAnchor = undefined;
+    },
     dispatchNext: (ctx) => {
       if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
       if (controlDispatchPending) {
@@ -3393,6 +3436,7 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
       if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
         nextDispatchAnnouncementRequested = false;
         controlDispatchPending = true;
+        const announcementGeneration = nextDispatchAnnouncementGeneration;
         const dispatchGeneration = deps.getDispatchGeneration?.();
         deps.updateStatus(ctx);
         void deps.sendTextReply(
@@ -3401,8 +3445,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
           "<b>⏩ Dispatching next queued turn.</b>",
           { target: dispatchPlan.item.target },
         ).catch((error) => {
-          deps.recordRuntimeEvent?.("dispatch", error, { phase: "next-announcement" });
+          deps.recordRuntimeEvent?.("dispatch", error, {
+            phase: "next-announcement",
+          });
         }).finally(() => {
+          try {
+            deps.reconcileNextDispatchAnnouncementReplyOwnership?.(
+              dispatchPlan.item,
+            );
+          } catch (error) {
+            deps.recordRuntimeEvent?.("dispatch", error, {
+              phase: "next-announcement-reply-ownership",
+            });
+          }
           controlDispatchPending = false;
           if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
           if (
@@ -3410,6 +3465,10 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
             deps.isDispatchGenerationActive &&
             !deps.isDispatchGenerationActive(dispatchGeneration)
           ) return;
+          if (announcementGeneration !== nextDispatchAnnouncementGeneration) {
+            if (nextDispatchAnnouncementRequested) controller.dispatchNext(ctx);
+            return;
+          }
           executePlan();
         });
         return;

package/node_modules/@llblab/pi-telegram/lib/replies.ts

@@ -68,6 +68,7 @@ export function createReplyDedupRuntime(): ReplyDedupRuntime {
 // --- Transport-level dedup ---
 
 const lastRepliedToMessageIdByTarget = new Map<string, number>();
+const replyDedupPreservedOnNextReset = new Map<string, number>();
 let replyDedupGeneration = 0;
 
 function getReplyDedupTargetKey(
@@ -83,6 +84,23 @@ function getReplyDedupTargetKey(
 export function resetTransportReplyDedup(): void {
   replyDedupGeneration += 1;
   lastRepliedToMessageIdByTarget.clear();
+  for (const [key, messageId] of replyDedupPreservedOnNextReset) {
+    lastRepliedToMessageIdByTarget.set(key, messageId);
+  }
+  replyDedupPreservedOnNextReset.clear();
+}
+
+/** Keeps a successfully published transition notice as the first reply of the
+ * next agent turn. The following agent-start reset consumes this one-shot
+ * preservation, so later messages in that turn do not repeat the reply header. */
+export function preserveTransportReplyDedupOnNextReset(
+  chatId: number,
+  messageId: number,
+  target?: TelegramTarget,
+): void {
+  const key = getReplyDedupTargetKey(chatId, target);
+  if (lastRepliedToMessageIdByTarget.get(key) !== messageId) return;
+  replyDedupPreservedOnNextReset.set(key, messageId);
 }
 
 export function buildTelegramReplyParameters(

package/node_modules/@llblab/pi-telegram/lib/routing.ts

@@ -627,6 +627,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestNextDispatchAnnouncement?: () => void;
+  cancelNextDispatchAnnouncement?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -2222,6 +2223,10 @@ export function createTelegramInboundRouteRuntime<
     isContextActive: deps.isContextActive,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
     requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+    cancelNextTransitionAnnouncements: () => {
+      deps.activeTurnRuntime.clearNextAbortAnnouncement();
+      deps.cancelNextDispatchAnnouncement?.();
+    },
     requestDeferredDispatchNextQueuedTelegramTurn:
       deps.requestDeferredDispatchNextQueuedTelegramTurn,
     startTypingLoop: deps.startTypingLoop,
@@ -2297,6 +2302,8 @@ export function createTelegramInboundRouteRuntime<
     },
     getPromptTemplateCommands,
     sendTextReply: deps.sendTextReply,
+    markActiveTurnNextAbortAnnouncement:
+      deps.activeTurnRuntime.markNextAbortAnnouncement,
     getActiveTurnReply: () => {
       const activeTurn = deps.activeTurnRuntime.get();
       if (!activeTurn) return undefined;

package/node_modules/@llblab/pi-telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.51.0",
+  "version": "0.51.1",
   "private": false,
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -44,8 +44,8 @@
     "@llblab/pi-clean-room": "0.1.1",
     "@llblab/pi-codex-usage": "0.10.0",
     "@llblab/pi-grow-loop": "0.8.1",
-    "@llblab/pi-state-flow": "0.18.0",
-    "@llblab/pi-telegram": "0.51.0",
+    "@llblab/pi-state-flow": "0.18.1",
+    "@llblab/pi-telegram": "0.51.1",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [