@llblab/pi-telegram 0.37.2 → 0.39.0

package/lib/commands.ts

@@ -9,6 +9,7 @@ import {
   TELEGRAM_DEFAULT_PROFILE_NAME,
 } from "./config.ts";
 import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
+import { escapeHtml } from "./rendering.ts";
 import type { TelegramBridgeStatusLineOptions } from "./status.ts";
 import {
   createTelegramControlItemBuilder,
@@ -185,9 +186,24 @@ export function formatTelegramCommandEmojiPrefix(
   return `${getTelegramCommandEmoji(command)} `;
 }
 
+export function formatTelegramInformationHeading(
+  emoji: string,
+  text: string,
+): string {
+  return `<b>${escapeHtml(emoji)} ${escapeHtml(text)}</b>`;
+}
+
 export const TELEGRAM_COMPACTION_STARTED_TEXT =
-  `${formatTelegramCommandEmojiPrefix("compact")}Compaction started.`;
-export const TELEGRAM_COMPACTION_COMPLETED_TEXT = "✅ Compaction completed.";
+  formatTelegramInformationHeading(
+    getTelegramCommandEmoji("compact"),
+    "Compaction started.",
+  );
+export const TELEGRAM_COMPACTION_COMPLETED_TEXT =
+  formatTelegramInformationHeading("✅", "Compaction completed.");
+export const TELEGRAM_COMPACTION_STARTED_MARKDOWN =
+  `**${formatTelegramCommandEmojiPrefix("compact")}Compaction started.**`;
+export const TELEGRAM_COMPACTION_COMPLETED_MARKDOWN =
+  "**✅ Compaction completed.**";
 
 function formatTelegramBotCommandDescription(
   command: TelegramCommandEmojiName,
@@ -585,7 +601,10 @@ export interface TelegramStopCommandDeps {
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   abortCurrentTurn: () => void;
   updateStatus: () => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }
 
 export interface TelegramRuntimeEventRecorderPort {
@@ -619,7 +638,10 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
     onComplete: () => void;
     onError: (error: unknown) => void;
   }) => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
   suppressStartNotice?: boolean;
 }
 
@@ -921,8 +943,11 @@ export function createTelegramCommandTargetRuntime<
         await deps.sendTextReply(
           target.chatId,
           target.replyToMessageId,
-          "Settings menu is unavailable.",
-          { target },
+          formatTelegramInformationHeading(
+            "🚫",
+            "Settings menu is unavailable.",
+          ),
+          { target, parseMode: "HTML" },
         );
         return;
       }
@@ -1165,7 +1190,10 @@ export async function handleTelegramStopCommand(
         ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
         : "";
     if (clearedCount > 0) deps.updateStatus();
-    await deps.sendTextReply(`No active turn.${clearedSuffix}`);
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("💤", `No active turn.${clearedSuffix}`),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.abortCurrentTurn();
@@ -1174,7 +1202,13 @@ export async function handleTelegramStopCommand(
     clearedCount > 0
       ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
       : "";
-  await deps.sendTextReply(`Aborted current turn.${clearedSuffix}`);
+  await deps.sendTextReply(
+    formatTelegramInformationHeading(
+      "⏹️",
+      `Aborted current turn.${clearedSuffix}`,
+    ),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramAbortCommand(deps: {
@@ -1184,17 +1218,26 @@ export async function handleTelegramAbortCommand(deps: {
   abortCurrentTurn: () => void;
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   updateStatus: () => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasAbortHandler()) {
-    await deps.sendTextReply("No active turn.");
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("💤", "No active turn."),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.setFoldQueuedPromptsIntoHistory(deps.hasActiveTelegramTurn());
   deps.abortCurrentTurn();
   deps.updateStatus();
-  await deps.sendTextReply("Aborted current turn.");
+  await deps.sendTextReply(
+    formatTelegramInformationHeading("⏹️", "Aborted current turn."),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramNextCommand(deps: {
@@ -1213,7 +1256,10 @@ export async function handleTelegramNextCommand(deps: {
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasQueuedItems()) {
-    await deps.sendTextReply("<b>Queue is empty.</b>", { parseMode: "HTML" });
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("⌛", "Queue is empty."),
+      { parseMode: "HTML" },
+    );
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
@@ -1221,17 +1267,30 @@ export async function handleTelegramNextCommand(deps: {
     deps.abortCurrentTurn();
     deps.updateStatus();
     await deps.sendTextReply(
-      "Aborted current turn. Dispatching next queued turn.",
+      formatTelegramInformationHeading(
+        "⏩",
+        "Aborted! Dispatching next queued turn.",
+      ),
+      { parseMode: "HTML" },
     );
     return;
   }
   if (!deps.isIdle()) {
-    await deps.sendTextReply("Pi is busy. Send /abort or /stop first.");
+    await deps.sendTextReply(
+      formatTelegramInformationHeading(
+        "⏳",
+        "Pi is busy. Send /abort or /stop first.",
+      ),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.dispatchNextQueuedTurn();
   deps.updateStatus();
-  await deps.sendTextReply("Dispatching next queued turn.");
+  await deps.sendTextReply(
+    formatTelegramInformationHeading("▶️", "Dispatching next queued turn."),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramContinueCommand<TMessage, TContext>(
@@ -1301,15 +1360,15 @@ export async function handleTelegramCompactConfirmationCallback<TContext>(
   const chatId = callbackMessage?.chat?.id;
   const messageId = callbackMessage?.message_id;
   if (typeof chatId !== "number" || typeof messageId !== "number") {
-    await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+    await deps.answerCallbackQuery(query.id, "⌛ Interactive message expired.");
     return true;
   }
   if (query.data === "compact:cancel") {
     await deps.editInteractiveMessage(
       chatId,
       messageId,
-      "Compaction cancelled.",
-      "plain",
+      "<b>🚫 Compaction cancelled.</b>",
+      "html",
       { inline_keyboard: [] },
     );
     await deps.answerCallbackQuery(query.id);
@@ -1319,7 +1378,7 @@ export async function handleTelegramCompactConfirmationCallback<TContext>(
     chatId,
     messageId,
     TELEGRAM_COMPACTION_STARTED_TEXT,
-    "plain",
+    "html",
     { inline_keyboard: [] },
   );
   await deps.answerCallbackQuery(query.id);
@@ -1345,7 +1404,11 @@ export async function handleTelegramCompactCommand(
     deps.isCompactionInProgress()
   ) {
     await deps.sendTextReply(
-      "Cannot compact while Pi or the Telegram queue is busy. Wait for queued turns to finish or send /abort first.",
+      formatTelegramInformationHeading(
+        "⏳",
+        "Cannot compact while Pi or the Telegram queue is busy. Wait for queued turns to finish or send /abort first.",
+      ),
+      { parseMode: "HTML" },
     );
     return;
   }
@@ -1359,7 +1422,9 @@ export async function handleTelegramCompactCommand(
         deps.setCompactionInProgress(false);
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
-        void deps.sendTextReply(TELEGRAM_COMPACTION_COMPLETED_TEXT);
+        void deps.sendTextReply(TELEGRAM_COMPACTION_COMPLETED_TEXT, {
+          parseMode: "HTML",
+        });
       },
       onError: (error) => {
         deps.stopTypingLoop?.();
@@ -1368,7 +1433,13 @@ export async function handleTelegramCompactCommand(
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
         deps.recordRuntimeEvent?.("compact", error);
         const errorMessage = getTelegramCommandErrorMessage(error);
-        void deps.sendTextReply(`Compaction failed: ${errorMessage}`);
+        void deps.sendTextReply(
+          formatTelegramInformationHeading(
+            "❌",
+            `Compaction failed: ${errorMessage}`,
+          ),
+          { parseMode: "HTML" },
+        );
       },
     });
   } catch (error) {
@@ -1377,13 +1448,19 @@ export async function handleTelegramCompactCommand(
     deps.updateStatus();
     deps.recordRuntimeEvent?.("compact", error);
     const errorMessage = getTelegramCommandErrorMessage(error);
-    await deps.sendTextReply(`Compaction failed: ${errorMessage}`);
+    await deps.sendTextReply(
+      formatTelegramInformationHeading(
+        "❌",
+        `Compaction failed: ${errorMessage}`,
+      ),
+      { parseMode: "HTML" },
+    );
     return;
   }
   if (!deps.suppressStartNotice) {
-    await deps.sendTextReply(
-      TELEGRAM_COMPACTION_STARTED_TEXT,
-    );
+    await deps.sendTextReply(TELEGRAM_COMPACTION_STARTED_TEXT, {
+      parseMode: "HTML",
+    });
   }
 }
 

package/lib/config.ts

@@ -118,9 +118,8 @@ export interface TelegramConfig {
   /** @deprecated use assistant.rendering */
   assistantRendering?: TelegramAssistantRenderingMode;
   voice?: {
-    replyMode?: "hidden" | "mirror" | "always";
-    /** Whether to attach the provider's transcriptText as caption on voice messages */
-    sendTranscript?: boolean;
+    /** `hidden` is a read-only compatibility alias for the former manual mode. */
+    replyMode?: "manual" | "hidden" | "mirror" | "always";
   };
   time?: TelegramTimeConfig;
   threads?: {
@@ -845,10 +844,10 @@ export function createTelegramActivityVerbositySetter(
 
 export function createTelegramVoiceReplyModeGetter(
   configStore: Pick<TelegramConfigStore, "get">,
-): () => "hidden" | "mirror" | "always" {
+): () => "manual" | "mirror" | "always" {
   return () => {
     const mode = configStore.get().voice?.replyMode;
-    return mode === "mirror" || mode === "always" ? mode : "hidden";
+    return mode === "mirror" || mode === "always" ? mode : "manual";
   };
 }
 
@@ -863,11 +862,15 @@ export function createTelegramVoiceReplyModeConfiguredChecker(
 
 export function createTelegramVoiceReplyModeSetter(
   configStore: TelegramMutableConfigStore,
-): (replyMode: "hidden" | "mirror" | "always" | undefined) => Promise<void> {
+): (replyMode: "manual" | "hidden" | "mirror" | "always" | undefined) => Promise<void> {
   return async (replyMode) => {
     await loadLatestTelegramConfig(configStore);
     const current = configStore.get();
-    if (replyMode === undefined || replyMode === "hidden") {
+    if (
+      replyMode === undefined ||
+      replyMode === "manual" ||
+      replyMode === "hidden"
+    ) {
       const { replyMode: _replyMode, ...remainingVoice } = current.voice ?? {};
       const next = { ...current };
       if (Object.keys(remainingVoice).length > 0) next.voice = remainingVoice;

package/lib/journal.ts

@@ -3381,15 +3381,8 @@ export function createTelegramUpdateJournalStore(
         const recoveredUpdateIds = [...requestedIds].sort((a, b) => a - b);
         const published = publishMutation(
           current,
-          current.file.entries.map((entry) =>
-            requestedIds.has(entry.updateId)
-              ? {
-                  updateId: entry.updateId,
-                  update: entry.update,
-                  admittedAtMs: entry.admittedAtMs,
-                  state: "pending" as const,
-                }
-              : entry,
+          current.file.entries.filter(
+            (entry) => !requestedIds.has(entry.updateId),
           ),
           true,
         );

package/lib/lifecycle.ts

@@ -345,25 +345,27 @@ export function createTelegramBridgeSessionLifecycleAssembly<
     stopPolling: suspendForReplacement,
     clearPendingMediaGroups: deps.services.suspendGroupedInput,
   });
-  const servicesLifecycle = appendTelegramLifecycleHooks(
-    queueLifecycle,
-    {
-      async onSessionStart(event, ctx) {
-        deps.services.resumeGroupedInput(ctx);
-        await deps.services.delivery.onSessionStart();
-        await deps.services.polling.onSessionStart(event, ctx);
-        deps.services.capabilityMonitor.start(ctx);
-        deps.services.queueWatchdog.start(ctx);
-      },
-      async onSessionShutdown() {
-        await deps.services.delivery.onSessionShutdown();
-        deps.services.queueWatchdog.stop();
-        deps.services.capabilityMonitor.stop();
-        await deps.services.inboundWorker.onSessionShutdown();
-      },
+  const servicesLifecycle: TelegramSessionLifecycleHooks = {
+    async onSessionStart(event, ctx) {
+      await queueLifecycle.onSessionStart(event, ctx);
+      if (!isSessionActive(ctx)) return;
+      deps.services.resumeGroupedInput(ctx);
+      await deps.services.delivery.onSessionStart();
+      await deps.services.polling.onSessionStart(event, ctx);
+      deps.services.capabilityMonitor.start(ctx);
+      deps.services.queueWatchdog.start(ctx);
     },
-    isSessionActive,
-  );
+    async onSessionShutdown(event, ctx) {
+      if (!isSessionActive(ctx)) return;
+      await deps.services.delivery.onSessionShutdown();
+      if (!isSessionActive(ctx)) return;
+      deps.services.queueWatchdog.stop();
+      deps.services.capabilityMonitor.stop();
+      await queueLifecycle.onSessionShutdown(event, ctx);
+      if (!isSessionActive(ctx)) return;
+      await deps.services.inboundWorker.onSessionShutdown();
+    },
+  };
   const followerLifecycle = appendTelegramLifecycleHooks(
     servicesLifecycle,
     {

package/lib/menu-queue.ts

@@ -73,6 +73,10 @@ function toTelegramQueueMenuItems<Context>(
   });
 }
 
+function formatSkippedTelegramQueuePosition(position: number): string {
+  return Array.from(String(position), (char) => `${char}\u0335`).join("");
+}
+
 function buildTelegramQueueMenuReplyMarkup(
   items: readonly TelegramQueueMenuItem[],
   emptyRefreshIndex = 0,
@@ -86,7 +90,7 @@ function buildTelegramQueueMenuReplyMarkup(
       : "queue:refresh";
   const refreshRow = [{ text: "🌀 Refresh", callback_data: refreshData }];
   if (items.length === 0) return { inline_keyboard: [backRow, refreshRow] };
-  const rows = items.map((item, index) => {
+  const rows = items.map((item) => {
     const prefix = item.reactionSuppressionEmoji
       ? `${item.reactionSuppressionEmoji} `
       : item.isPriority
@@ -94,7 +98,11 @@ function buildTelegramQueueMenuReplyMarkup(
         : item.hasAttachments
           ? "📎 "
           : "";
-    const label = `${index + 1}. ${prefix}${item.statusSummary}`;
+    const position = item.reactionSuppressionEmoji
+      ? formatSkippedTelegramQueuePosition(item.queuePosition)
+      : String(item.queuePosition);
+    const ordinalSeparator = item.reactionSuppressionEmoji ? "\u200A" : "";
+    const label = `${position}${ordinalSeparator}. ${prefix}${item.statusSummary}`;
     return [
       {
         text: label,
@@ -162,7 +170,10 @@ function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
     : item.isPriority
       ? ` ${item.priorityEmoji ?? "⚡"}`
       : "";
-  const heading = `<b>${item.queuePosition}.</b>${badge}`;
+  const position = item.reactionSuppressionEmoji
+    ? `<s>${item.queuePosition}</s>.`
+    : `<b>${item.queuePosition}.</b>`;
+  const heading = `${position}${badge}`;
   const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
   return `${heading}\n${preview}`;
 }
@@ -182,7 +193,7 @@ function buildTelegramQueueItemSubmenuReplyMarkup(
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
         },
         {
-          text: isPriority ? "⚫️ Normal" : "🟣 Normal",
+          text: isPriority ? "⚫️ Normal" : "🔵 Normal",
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
         },
       ],

package/lib/menu-settings.ts

@@ -149,9 +149,7 @@ export const TIME_INJECTION_MODE_SETTINGS_TITLE =
   "<b>🕒 Time injection mode:</b>";
 export const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>👄 Voice reply mode:</b>";
 
-type TelegramVoiceReplyModeSetting = TelegramVoiceReplyMode | "hidden";
-
-function getVoiceReplyModeLabel(mode: TelegramVoiceReplyModeSetting): string {
+function getVoiceReplyModeLabel(mode: TelegramVoiceReplyMode): string {
   return mode;
 }
 
@@ -162,8 +160,8 @@ function getTelegramSettingsStateValueLabel(value: string): string {
 function getVoiceReplyModeSetting(
   mode: TelegramVoiceReplyMode,
   configured: boolean,
-): TelegramVoiceReplyModeSetting {
-  return configured ? mode : "hidden";
+): TelegramVoiceReplyMode {
+  return configured ? mode : "manual";
 }
 
 export function buildTelegramSettingsMenuText(): string {
@@ -246,8 +244,8 @@ export function buildVoiceReplyModeSettingsText(
     "",
     "Controls when pi-telegram converts assistant text replies into Telegram voice messages.",
     "",
-    "<code>-</code> <code>hidden</code> (default): add no automatic voice context; explicit 'telegram_voice' actions still work.",
-    "<code>-</code> <code>mirror</code>: voice input activates automatic voice delivery; text input follows 'hidden' behavior.",
+    "<code>-</code> <code>manual</code> (default): add no automatic voice context; explicit 'telegram_voice' actions still work.",
+    "<code>-</code> <code>mirror</code>: voice input activates automatic voice delivery; text input follows 'manual' behavior.",
     "<code>-</code> <code>always</code>: activate automatic voice delivery for every reply.",
   ].join("\n");
 }
@@ -502,7 +500,7 @@ export function buildVoiceReplyModeSettingsReplyMarkup(
   configured = true,
 ): TelegramSettingsMenuReplyMarkup {
   const activeMode = getVoiceReplyModeSetting(mode, configured);
-  const modes: TelegramVoiceReplyModeSetting[] = ["hidden", "mirror", "always"];
+  const modes: TelegramVoiceReplyMode[] = ["manual", "mirror", "always"];
   return {
     inline_keyboard: [
       [{ text: "⬆️ Back", callback_data: "settings:list" }],
@@ -661,12 +659,18 @@ export async function handleTelegramSettingsMenuCallbackAction(
   }
   if (data.startsWith("settings:set:voice-reply:")) {
     const mode = data.slice("settings:set:voice-reply:".length);
-    if (mode === "hidden" || mode === "mirror" || mode === "always") {
-      await deps.setVoiceReplyMode(mode === "hidden" ? undefined : mode);
+    if (
+      mode === "manual" ||
+      mode === "hidden" ||
+      mode === "mirror" ||
+      mode === "always"
+    ) {
+      const normalizedMode = mode === "hidden" ? "manual" : mode;
+      await deps.setVoiceReplyMode(normalizedMode);
       await updateVoiceReplyModeSettingsMessage(deps);
       await deps.answerCallbackQuery(
         callbackQueryId,
-        `Voice reply mode: ${mode}`,
+        `Voice reply mode: ${normalizedMode}`,
       );
       return true;
     }

package/lib/menu.ts

@@ -255,7 +255,10 @@ export interface TelegramMenuActionRuntimeDeps<
     chatId: number,
     replyToMessageId: number,
     text: string,
-    options?: { target?: { chatId: number; threadId?: number } },
+    options?: {
+      target?: { chatId: number; threadId?: number };
+      parseMode?: "HTML";
+    },
   ) => Promise<unknown>;
   sectionRegistry?: TelegramSectionRegistry;
   isVoiceReplyActive?: () => boolean;
@@ -798,8 +801,8 @@ export function createTelegramMenuActionRuntime<
           await deps.sendTextReply(
             chatId,
             replyToMessageId,
-            "Cannot open status while Pi is busy. Send /abort, /next, or /stop.",
-            { target: { chatId, threadId } },
+            "<b>⏳ Cannot open status while Pi is busy. Send /abort, /next, or /stop.</b>",
+            { target: { chatId, threadId }, parseMode: "HTML" },
           );
         },
         getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
@@ -835,16 +838,16 @@ export function createTelegramMenuActionRuntime<
           await deps.sendTextReply(
             chatId,
             replyToMessageId,
-            "Cannot switch model while Pi is busy. Send /abort, /next, or /stop.",
-            { target: { chatId, threadId } },
+            "<b>⏳ Cannot switch model while Pi is busy. Send /abort, /next, or /stop.</b>",
+            { target: { chatId, threadId }, parseMode: "HTML" },
           );
         },
         sendNoModelsMessage: async () => {
           await deps.sendTextReply(
             chatId,
             replyToMessageId,
-            "No available models with configured auth.",
-            { target: { chatId, threadId } },
+            "<b>🚫 No available models with configured auth.</b>",
+            { target: { chatId, threadId }, parseMode: "HTML" },
           );
         },
         getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),

package/lib/outbound-voice.ts

@@ -100,17 +100,6 @@ async function ensureTelegramVoiceFileFormat(
   );
 }
 
-function extractVoiceResult(result: any): {
-  filePath: string;
-  transcriptText?: string;
-} {
-  if (typeof result === "string") return { filePath: result };
-  return {
-    filePath: result.audioPath,
-    transcriptText: result.transcriptText,
-  };
-}
-
 async function sendVoiceChatAction(
   deps: TelegramVoiceReplySenderDeps,
   chatId: number,
@@ -132,7 +121,6 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
     options?: {
       replyToPrompt?: boolean;
       replyMarkup?: unknown;
-      transcriptText?: string;
     },
   ): Promise<void> => {
     const voiceFilePath = await ensureTelegramVoiceFileFormat(filePath);
@@ -148,7 +136,6 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
       "sendVoice",
       {
         chat_id: String(turn.chatId),
-        ...(options?.transcriptText ? { caption: options.transcriptText } : {}),
         ...(replyParameters ? { reply_parameters: replyParameters } : {}),
         ...(turn.target
           ? Object.fromEntries(
@@ -257,13 +244,11 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
           continue;
         }
 
-        const { filePath, transcriptText } = extractVoiceResult(providerResult);
-        voiceFilePath = filePath;
-        originalFilePath = filePath;
-        await uploadVoiceFile(turn, filePath, {
+        voiceFilePath = providerResult;
+        originalFilePath = providerResult;
+        await uploadVoiceFile(turn, providerResult, {
           replyToPrompt: options?.replyToPrompt,
           replyMarkup: options?.replyMarkup,
-          transcriptText,
         });
         return;
       } catch (error) {

package/lib/prompts.ts

@@ -14,11 +14,11 @@ export const TELEGRAM_DISCONNECTED_CONTEXT_MESSAGE =
 
 const LOCAL_SYSTEM_PROMPT_SUFFIX = `
 
-${TELEGRAM_CONNECTED_CONTEXT_MESSAGE} Load the \`telegram-bridge\` Skill for Telegram-originated turns or explicit requests involving Telegram delivery, actions, Threaded Mode, or diagnosis. Do not use Telegram-specific features from unrelated local/TUI prompts.`;
+${TELEGRAM_CONNECTED_CONTEXT_MESSAGE} For Telegram work, consult bundled Skills in routing order: \`telegram-bridge\` for the transport and turn protocol, \`generated-control-surface\` when contextual controls materially shorten feedback, then \`generative-apps\` when the interaction warrants a reusable deterministic app. Load a Skill only if its instructions are not already present in the current context. Do not use Telegram-specific features from unrelated local/TUI prompts.`;
 
 const TELEGRAM_TURN_SYSTEM_PROMPT_SUFFIX = `
 
-Telegram turn note: Load and follow the \`telegram-bridge\` Skill.`;
+Telegram turn note: Follow the applicable bundled Telegram Skills in routing order; load only missing instructions.`;
 
 export const TELEGRAM_ATTACH_PROMPT_SNIPPET =
   "Queue files for the active Telegram reply; outside Telegram turns, send files directly to Telegram.";