@llblab/pi-telegram 0.6.3 → 0.7.0

package/lib/queue.ts

@@ -1,6 +1,7 @@
 /**
- * Telegram queue and queue-runtime domain helpers
- * Owns queue items, queue mutations, dispatch and lifecycle planning, session resets, and queue-adjacent runtime helpers
+ * Telegram queue core contracts and pure planning helpers
+ * Zones: telegram queue, pi agent lifecycle, scheduling
+ * Owns queue item contracts, lane admission, pure queue mutations, and dispatch planning
  */
 
 // --- Queue Items ---
@@ -178,6 +179,14 @@ export function createTelegramQueueStore<TContext = unknown>(
   };
 }
 
+export function createTelegramQueueItemCountGetter<TContext = unknown>(
+  store: Pick<TelegramQueueStore<TContext>, "getQueuedItems">,
+): () => number {
+  return function getTelegramQueueItemCount() {
+    return store.getQueuedItems().length;
+  };
+}
+
 export function createTelegramActiveTurnStore<
   TTurn extends PendingTelegramTurn = PendingTelegramTurn,
 >(): TelegramActiveTurnStore<TTurn> {
@@ -344,7 +353,7 @@ function formatTelegramQueueItemStatusSummary<TContext = unknown>(
   item: TelegramQueueItem<TContext>,
 ): string {
   if (item.queueLane === "priority") {
-    return `⬆ ${item.statusSummary}`;
+    return `⚡ ${item.statusSummary}`;
   }
   return item.statusSummary;
 }
@@ -665,18 +674,32 @@ export type TelegramAgentLifecycleHooksRuntimeDeps<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
+  TReplyMarkup = unknown,
 > = TelegramAgentStartHookRuntimeDeps<TTurn, TContext> &
-  TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage> &
+  TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage, TReplyMarkup> &
   TelegramToolExecutionHookRuntimeDeps<TContext>;
 
 export function createTelegramAgentLifecycleHooks<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
->(deps: TelegramAgentLifecycleHooksRuntimeDeps<TTurn, TContext, TMessage>) {
+  TReplyMarkup = unknown,
+>(
+  deps: TelegramAgentLifecycleHooksRuntimeDeps<
+    TTurn,
+    TContext,
+    TMessage,
+    TReplyMarkup
+  >,
+) {
   return {
     onAgentStart: createTelegramAgentStartHook<TTurn, TContext>(deps),
-    onAgentEnd: createTelegramAgentEndHook<TTurn, TContext, TMessage>(deps),
+    onAgentEnd: createTelegramAgentEndHook<
+      TTurn,
+      TContext,
+      TMessage,
+      TReplyMarkup
+    >(deps),
     ...createTelegramToolExecutionHooks<TContext>(deps),
   };
 }
@@ -737,6 +760,7 @@ export interface TelegramAgentEndOutboundReplyPlan<TReplyMarkup = unknown> {
 
 export interface TelegramAgentEndRuntimeDeps<
   TTurn extends PendingTelegramTurn,
+  TReplyMarkup = unknown,
 > {
   turn: TTurn | undefined;
   assistant: TelegramAgentEndAssistantResult;
@@ -750,13 +774,13 @@ export interface TelegramAgentEndRuntimeDeps<
     chatId: number,
     markdown: string,
     replyToMessageId: number,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<boolean>;
   sendMarkdownReply: (
     chatId: number,
     replyToMessageId: number,
     markdown: string,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<unknown>;
   sendTextReply: (
     chatId: number,
@@ -764,7 +788,9 @@ export interface TelegramAgentEndRuntimeDeps<
     text: string,
   ) => Promise<unknown>;
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
-  planOutboundReply?: (markdown: string) => TelegramAgentEndOutboundReplyPlan;
+  planOutboundReply?: (
+    markdown: string,
+  ) => TelegramAgentEndOutboundReplyPlan<TReplyMarkup>;
   sendOutboundReplyArtifacts?: (
     turn: TTurn,
     plan: TelegramAgentEndOutboundReplyPlan,
@@ -776,6 +802,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
+  TReplyMarkup = unknown,
 > {
   getActiveTurn: () => TTurn | undefined;
   extractAssistant: (
@@ -790,11 +817,11 @@ export interface TelegramAgentEndHookRuntimeDeps<
   ) => void;
   clearPreview: (chatId: number) => Promise<void>;
   setPreviewPendingText: (text: string) => void;
-  finalizeMarkdownPreview: TelegramAgentEndRuntimeDeps<TTurn>["finalizeMarkdownPreview"];
-  sendMarkdownReply: TelegramAgentEndRuntimeDeps<TTurn>["sendMarkdownReply"];
+  finalizeMarkdownPreview: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>["finalizeMarkdownPreview"];
+  sendMarkdownReply: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>["sendMarkdownReply"];
   sendTextReply: TelegramAgentEndRuntimeDeps<TTurn>["sendTextReply"];
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
-  planOutboundReply?: TelegramAgentEndRuntimeDeps<TTurn>["planOutboundReply"];
+  planOutboundReply?: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>["planOutboundReply"];
   sendOutboundReplyArtifacts?: TelegramAgentEndRuntimeDeps<TTurn>["sendOutboundReplyArtifacts"];
 }
 
@@ -872,7 +899,15 @@ export function createTelegramAgentEndHook<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
->(deps: TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage>) {
+  TReplyMarkup = unknown,
+>(
+  deps: TelegramAgentEndHookRuntimeDeps<
+    TTurn,
+    TContext,
+    TMessage,
+    TReplyMarkup
+  >,
+) {
   return async function onAgentEnd(
     event: TelegramAgentEndHookEvent<TMessage>,
     ctx: TContext,
@@ -903,7 +938,8 @@ export function createTelegramAgentEndHook<
 
 export async function handleTelegramAgentEndRuntime<
   TTurn extends PendingTelegramTurn,
->(deps: TelegramAgentEndRuntimeDeps<TTurn>): Promise<void> {
+  TReplyMarkup = unknown,
+>(deps: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>): Promise<void> {
   const { turn, assistant } = deps;
   const rawFinalText = assistant.text;
   const outboundReply = rawFinalText
@@ -934,7 +970,7 @@ export async function handleTelegramAgentEndRuntime<
       turn.chatId,
       turn.replyToMessageId,
       assistant.errorMessage ||
-        "Telegram bridge: pi failed while processing the request.",
+        "Telegram bridge: π failed while processing the request.",
     );
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
     return;

package/lib/rendering.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram preview and markdown rendering helpers
+ * Zones: telegram rendering, shared text utils
  * Converts assistant output into Telegram-safe plain text and HTML chunks with chunk-boundary handling
  */
 

package/lib/replies.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram reply delivery helpers
+ * Zones: telegram outbound, rendering transport
  * Owns rendered-message delivery, reply transport wiring, and plain or markdown final replies
  */
 
@@ -10,10 +11,48 @@ import {
   type TelegramRenderMode,
 } from "./rendering.ts";
 
+// --- Reply Dedup ---
+
+/** Non-persistent reply deduplication for a single agent turn.
+ *  First reply to a prompt gets `reply_parameters.reply_to_message_id`;
+ *  subsequent replies in the same turn skip it to avoid stacking
+ *  duplicate reply headers in the chat viewport. */
+export interface ReplyDedupRuntime {
+  /** Returns true if this is the first reply for the given prompt
+   *  message id in the current turn. Side-effect: marks it replied. */
+  shouldReply(promptMessageId: number): boolean;
+  /** Reset the tracker when a new prompt enters the queue. */
+  reset(): void;
+}
+
+export function createReplyDedupRuntime(): ReplyDedupRuntime {
+  const replied = new Map<number, boolean>();
+  return {
+    shouldReply(promptMessageId: number): boolean {
+      if (replied.has(promptMessageId)) return false;
+      replied.set(promptMessageId, true);
+      return true;
+    },
+    reset(): void {
+      replied.clear();
+    },
+  };
+}
+
+// --- Transport-level dedup ---
+
+let lastRepliedToMessageId: number | undefined;
+
+export function resetTransportReplyDedup(): void {
+  lastRepliedToMessageId = undefined;
+}
+
 export function buildTelegramReplyParameters(
   messageId: number | undefined,
 ): TelegramReplyParameters | undefined {
   if (messageId === undefined) return undefined;
+  if (messageId === lastRepliedToMessageId) return undefined;
+  lastRepliedToMessageId = messageId;
   return { message_id: messageId, allow_sending_without_reply: true };
 }
 
@@ -219,13 +258,13 @@ export interface TelegramRenderedMessageRuntimeDeps<TReplyMarkup> {
 export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
   sendTextReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<number | undefined>;
   sendMarkdownReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     markdown: string,
     options?: { replyMarkup?: unknown },
   ) => Promise<number | undefined>;
@@ -332,3 +371,48 @@ export function createTelegramRenderedMessageRuntime<TReplyMarkup>(
     },
   };
 }
+
+// --- Dedup-wrapped Reply Wrappers ---
+
+/** Wrap a sendTextReply with reply dedup so only the first message
+ *  in a turn carries `reply_to_message_id`. */
+export function dedupSendTextReply(
+  dedup: ReplyDedupRuntime,
+  inner: (
+    chatId: number,
+    replyToMessageId: number | undefined,
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<number | undefined>,
+): (
+  chatId: number,
+  replyToMessageId: number,
+  text: string,
+  options?: { parseMode?: "HTML" },
+) => Promise<number | undefined> {
+  return async (chatId, replyToMessageId, text, options) => {
+    const effectiveReplyTo = dedup.shouldReply(replyToMessageId) ? replyToMessageId : undefined;
+    return inner(chatId, effectiveReplyTo, text, options);
+  };
+}
+
+/** Wrap a sendMarkdownReply with reply dedup. */
+export function dedupSendMarkdownReply<TReplyMarkup = unknown>(
+  dedup: ReplyDedupRuntime,
+  inner: (
+    chatId: number,
+    replyToMessageId: number | undefined,
+    markdown: string,
+    options?: { replyMarkup?: TReplyMarkup },
+  ) => Promise<number | undefined>,
+): (
+  chatId: number,
+  replyToMessageId: number,
+  markdown: string,
+  options?: { replyMarkup?: TReplyMarkup },
+) => Promise<number | undefined> {
+  return async (chatId, replyToMessageId, markdown, options) => {
+    const effectiveReplyTo = dedup.shouldReply(replyToMessageId) ? replyToMessageId : undefined;
+    return inner(chatId, effectiveReplyTo, markdown, options);
+  };
+}

package/lib/routing.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram inbound routing composition
+ * Zones: telegram inbound, orchestration, queue/menu/command composition
  * Wires authorized updates into menus, commands, media grouping, and prompt queueing
  */
 
@@ -11,6 +12,7 @@ import * as Media from "./media.ts";
 import * as Menu from "./menu.ts";
 import * as Model from "./model.ts";
 import * as Queue from "./queue.ts";
+import * as PromptTemplates from "./prompt-templates.ts";
 import type { TelegramBridgeRuntime } from "./runtime.ts";
 import * as Turns from "./turns.ts";
 import * as Updates from "./updates.ts";
@@ -25,11 +27,6 @@ export type TelegramRoutedCallbackQuery = Updates.TelegramCallbackQuery &
   Menu.MenuCallbackQuery;
 
 export interface TelegramInboundRouteRuntimeDeps<
-  TUpdate extends Updates.TelegramUpdateFlow & {
-    message?: TMessage;
-    edited_message?: TMessage;
-    callback_query?: TCallbackQuery;
-  },
   TMessage extends TelegramRoutedMessage,
   TCallbackQuery extends TelegramRoutedCallbackQuery,
   TContext,
@@ -51,6 +48,15 @@ export interface TelegramInboundRouteRuntimeDeps<
     Model.ScopedTelegramModel<TModel>
   >;
   menuActions: Menu.TelegramMenuActionRuntime<TContext, TModel>;
+  openQueueMenu: (
+    chatId: number,
+    replyToMessageId: number,
+    ctx: TContext,
+  ) => Promise<void>;
+  queueMenuCallbackHandler: (
+    query: TCallbackQuery,
+    ctx: TContext,
+  ) => Promise<boolean>;
   buttonActionStore?: OutboundHandlers.TelegramButtonActionStore;
   attachmentHandlerRuntime: TelegramAttachmentHandlerRuntime<TContext>;
   updateStatus: (ctx: TContext, error?: string) => void;
@@ -65,6 +71,7 @@ export interface TelegramInboundRouteRuntimeDeps<
     text: string,
   ) => Promise<number | undefined>;
   setMyCommands: Commands.TelegramBotCommandRegistrationDeps["setMyCommands"];
+  getCommands: () => Parameters<typeof PromptTemplates.getTelegramPromptTemplateCommands>[0];
   downloadFile: Media.DownloadTelegramMessageFilesDeps["downloadFile"];
   getThinkingLevel: () => Model.ThinkingLevel;
   setThinkingLevel: (level: Model.ThinkingLevel) => void;
@@ -94,7 +101,6 @@ export function createTelegramInboundRouteRuntime<
   TModel extends Model.MenuModel,
 >(
   deps: TelegramInboundRouteRuntimeDeps<
-    TUpdate,
     TMessage,
     TCallbackQuery,
     TContext,
@@ -159,8 +165,53 @@ export function createTelegramInboundRouteRuntime<
       );
       if (handled) return;
     }
+    const handledByQueue = await deps.queueMenuCallbackHandler(query, ctx);
+    if (handledByQueue) return;
     await menuCallbackHandler(query, ctx);
   };
+  const promptTurnBuilder = Turns.createTelegramPromptTurnRuntimeBuilder<
+    TMessage,
+    TContext
+  >({
+    allocateQueueOrder: deps.bridgeRuntime.queue.allocateItemOrder,
+    downloadFile: deps.downloadFile,
+    processAttachments: deps.attachmentHandlerRuntime.process,
+  });
+  const enqueueContinueTurn = async (
+    message: TMessage,
+    ctx: TContext,
+  ): Promise<void> => {
+    const enqueuePlan = Queue.planTelegramPromptEnqueue(
+      deps.telegramQueueStore.getQueuedItems(),
+      deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory(),
+    );
+    deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory(false);
+    const continueMessage = {
+      ...message,
+      text: "continue",
+      caption: undefined,
+    } as TMessage;
+    const turn = await promptTurnBuilder(
+      [continueMessage],
+      enqueuePlan.historyTurns,
+      ctx,
+    );
+    const continueTurn = {
+      ...turn,
+      queueLane: "priority" as const,
+      laneOrder: Number.MIN_SAFE_INTEGER + turn.queueOrder,
+      statusSummary: "continue",
+    };
+    deps.telegramQueueStore.setQueuedItems(enqueuePlan.remainingItems);
+    deps.queueMutationRuntime.append(continueTurn, ctx);
+    deps.dispatchNextQueuedTelegramTurn(ctx);
+  };
+  const reservedCommandNames = new Set(Commands.TELEGRAM_RESERVED_COMMAND_NAMES);
+  const getPromptTemplateCommands = () =>
+    PromptTemplates.getTelegramPromptTemplateCommands(
+      deps.getCommands(),
+      reservedCommandNames,
+    );
   const commandHandler = Commands.createTelegramCommandHandlerTargetRuntime<
     TMessage,
     TContext
@@ -181,15 +232,25 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.setCompactionInProgress,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    enqueueContinueTurn,
     compact: deps.compact,
     allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,
     allocateControlOrder: deps.bridgeRuntime.queue.allocateControlOrder,
     appendControlItem: deps.queueMutationRuntime.append,
     showStatus: deps.menuActions.sendStatusMessage,
     openModelMenu: deps.menuActions.openModelMenu,
+    openThinkingMenu: (message, ctx) => {
+      const chatId = (message as { chat: { id: number } }).chat.id;
+      return deps.menuActions.openThinkingMenu(chatId, message.message_id, ctx);
+    },
+    openQueueMenu: (message, ctx) => {
+      const chatId = (message as { chat: { id: number } }).chat.id;
+      return deps.openQueueMenu(chatId, message.message_id, ctx);
+    },
     getAllowedUserId: deps.configStore.getAllowedUserId,
     setAllowedUserId: deps.configStore.setAllowedUserId,
     setMyCommands: deps.setMyCommands,
+    getPromptTemplateCommands,
     persistConfig: deps.configStore.persist,
     sendTextReply: deps.sendTextReply,
     recordRuntimeEvent: deps.recordRuntimeEvent,
@@ -203,14 +264,7 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory,
     setPreserveQueuedTurnsAsHistory:
       deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
-    createTurn: Turns.createTelegramPromptTurnRuntimeBuilder<
-      TMessage,
-      TContext
-    >({
-      allocateQueueOrder: deps.bridgeRuntime.queue.allocateItemOrder,
-      downloadFile: deps.downloadFile,
-      processAttachments: deps.attachmentHandlerRuntime.process,
-    }),
+    createTurn: promptTurnBuilder,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
   }).enqueue;
@@ -220,6 +274,14 @@ export function createTelegramInboundRouteRuntime<
   >({
     extractRawText: Media.extractFirstTelegramMessageText,
     handleCommand: commandHandler,
+    expandPromptTemplateCommand: (commandName, args) =>
+      PromptTemplates.expandTelegramPromptTemplateCommand(
+        commandName,
+        args,
+        getPromptTemplateCommands(),
+      ),
+    replaceMessageText: (message, text) =>
+      ({ ...message, text, caption: undefined }) as TMessage,
     enqueueTurn: promptEnqueue,
   });
   const mediaDispatch = Media.createTelegramMediaGroupDispatchRuntime<

package/lib/runtime.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram bridge runtime-state helpers
+ * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 
@@ -350,6 +351,7 @@ export function createTelegramTypingLoopStarter<TContext>(
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
+          deps.updateStatus(ctx, message);
           deps.recordRuntimeEvent?.("typing", error, {
             chatId: targetChatId,
           });

package/lib/setup.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram setup prompt helpers
+ * Zones: pi agent command ui, telegram config
  * Computes token-prefill defaults and prompt mode selection for /telegram-setup
  */
 

package/lib/status.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram status rendering helpers
+ * Zones: telegram ui, pi agent diagnostics, tui
  * Builds usage, cost, and context summaries for the interactive Telegram status view
  */
 
@@ -41,6 +42,8 @@ export interface TelegramStatusActiveModel {
 export interface TelegramStatusContext {
   sessionManager: { getEntries(): TelegramStatusSessionEntry[] };
   getContextUsage(): TelegramContextUsage | undefined;
+  isIdle?: () => boolean;
+  hasPendingMessages?: () => boolean;
   modelRegistry: {
     isUsingOAuth(model: TelegramStatusActiveModel): boolean;
   };
@@ -406,12 +409,14 @@ export function buildTelegramStatusBarText(
     return `${label} ${theme.fg("muted", "disconnected")}`;
   if (!state.paired)
     return `${label} ${theme.fg("warning", "awaiting pairing")}`;
-  const queued = theme.fg("muted", state.queuedStatus);
+  const queued = state.queuedStatus ? theme.fg("muted", state.queuedStatus) : "";
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("accent", "compacting")}${queued}`;
   }
   if (state.processing) {
-    return `${label} ${theme.fg("accent", state.processingStatus ?? "processing")}${queued}`;
+    const processingStatus = state.processingStatus ?? "processing";
+    const processingToken = processingStatus === "active" ? "warning" : "accent";
+    return `${label} ${theme.fg(processingToken, processingStatus)}${queued}`;
   }
   return `${label} ${theme.fg("success", "connected")}`;
 }
@@ -528,6 +533,13 @@ function buildContextSummary(
   return `${percent}/${formatTokens(contextWindow)}`;
 }
 
+function buildStatusSummary(ctx: TelegramStatusContext): string {
+  if (ctx.hasPendingMessages?.()) return "pending";
+  if (ctx.isIdle?.() === false) return "active";
+  if (ctx.isIdle?.() === true) return "idle";
+  return "unknown";
+}
+
 export function buildStatusHtml(
   ctx: TelegramStatusContext,
   activeModel: TelegramStatusActiveModel | undefined,
@@ -536,7 +548,7 @@ export function buildStatusHtml(
   const usesSubscription = activeModel
     ? ctx.modelRegistry.isUsingOAuth(activeModel)
     : false;
-  const lines: string[] = [];
+  const lines: string[] = [buildStatusRow("Status", buildStatusSummary(ctx))];
   const usageSummary = buildUsageSummary(stats);
   const costSummary = buildCostSummary(stats, usesSubscription);
   if (usageSummary) {
@@ -546,8 +558,5 @@ export function buildStatusHtml(
     lines.push(buildStatusRow("Cost", costSummary));
   }
   lines.push(buildStatusRow("Context", buildContextSummary(ctx, activeModel)));
-  if (lines.length === 0) {
-    lines.push(buildStatusRow("Status", "No usage data yet."));
-  }
   return lines.join("\n");
 }

package/lib/turns.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram turn-building helpers
+ * Zones: telegram inbound, pi agent prompt content, queue
  * Owns prompt-turn summary and content construction so queued Telegram turns are assembled consistently
  */
 

package/lib/updates.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram updates domain helpers
+ * Zones: telegram inbound, authorization, routing plans
  * Owns update extraction, authorization, classification, execution planning, and runtime execution for Telegram updates
  */
 
@@ -25,6 +26,9 @@ export type TelegramReactionType =
   | TelegramReactionTypeEmoji
   | TelegramReactionTypeNonEmoji;
 
+export const TELEGRAM_PRIORITY_REACTION_EMOJIS = ["👍", "⚡", "❤", "🕊"] as const;
+export const TELEGRAM_REMOVAL_REACTION_EMOJIS = ["👎", "👻", "💔", "💩"] as const;
+
 export interface TelegramUpdateDeletion {
   deleted_business_messages?: { message_ids?: unknown };
 }
@@ -50,6 +54,21 @@ export function collectTelegramReactionEmojis(
   );
 }
 
+function hasAnyTelegramReactionEmoji(
+  emojis: Set<string>,
+  candidates: readonly string[],
+): boolean {
+  return candidates.some((emoji) => emojis.has(emoji));
+}
+
+function hasAddedTelegramReactionEmoji(
+  oldEmojis: Set<string>,
+  newEmojis: Set<string>,
+  candidates: readonly string[],
+): boolean {
+  return candidates.some((emoji) => !oldEmojis.has(emoji) && newEmojis.has(emoji));
+}
+
 export function extractDeletedTelegramMessageIds(
   update: TelegramUpdateDeletion,
 ): number[] {
@@ -579,8 +598,13 @@ export async function handleAuthorizedTelegramReactionUpdate<TContext>(
   }
   const oldEmojis = collectTelegramReactionEmojis(reactionUpdate.old_reaction);
   const newEmojis = collectTelegramReactionEmojis(reactionUpdate.new_reaction);
-  const dislikeAdded = !oldEmojis.has("👎") && newEmojis.has("👎");
-  if (dislikeAdded) {
+  if (
+    hasAddedTelegramReactionEmoji(
+      oldEmojis,
+      newEmojis,
+      TELEGRAM_REMOVAL_REACTION_EMOJIS,
+    )
+  ) {
     deps.removePendingMediaGroupMessages([reactionUpdate.message_id]);
     deps.removeQueuedTelegramTurnsByMessageIds(
       [reactionUpdate.message_id],
@@ -588,15 +612,21 @@ export async function handleAuthorizedTelegramReactionUpdate<TContext>(
     );
     return;
   }
-  const likeRemoved = oldEmojis.has("👍") && !newEmojis.has("👍");
-  if (likeRemoved) {
+  const hadPriorityReaction = hasAnyTelegramReactionEmoji(
+    oldEmojis,
+    TELEGRAM_PRIORITY_REACTION_EMOJIS,
+  );
+  const hasPriorityReaction = hasAnyTelegramReactionEmoji(
+    newEmojis,
+    TELEGRAM_PRIORITY_REACTION_EMOJIS,
+  );
+  if (hadPriorityReaction && !hasPriorityReaction) {
     deps.clearQueuedTelegramTurnPriorityByMessageId(
       reactionUpdate.message_id,
       deps.ctx,
     );
   }
-  const likeAdded = !oldEmojis.has("👍") && newEmojis.has("👍");
-  if (!likeAdded) return;
+  if (!hasAddedTelegramReactionEmoji(oldEmojis, newEmojis, TELEGRAM_PRIORITY_REACTION_EMOJIS)) return;
   deps.prioritizeQueuedTelegramTurnByMessageId(
     reactionUpdate.message_id,
     deps.ctx,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "private": false,
   "description": "Better Telegram DM bridge extension for pi",
   "type": "module",
@@ -31,6 +31,9 @@
     "index.ts",
     "lib/",
     "README.md",
+    "AGENTS.md",
+    "BACKLOG.md",
+    "CHANGELOG.md",
     "docs/",
     "screenshot.png"
   ],