@llblab/pi-telegram 0.13.2 → 0.14.0

package/lib/outbound-attachments.ts

@@ -53,9 +53,28 @@ export interface TelegramOutboundAttachmentToolRegistrationDeps extends Telegram
   maxAttachmentsPerTurn?: number;
   maxAttachmentSizeBytes?: number;
   getActiveTurn: () => TelegramOutboundAttachmentQueueTargetView | undefined;
+  getDefaultChatId?: () => number | undefined;
+  canSendDirect?: () => boolean;
+  sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
 }
 
+export interface TelegramOutboundMessagePlan {
+  markdown: string;
+  replyMarkup?: unknown;
+}
+
+export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
+  getDefaultChatId: () => number | undefined;
+  canSendDirect: () => boolean;
+  planMessage: (markdown: string) => TelegramOutboundMessagePlan;
+  sendMarkdownMessage: (
+    chatId: number,
+    markdown: string,
+    options?: { replyMarkup?: unknown },
+  ) => Promise<number | undefined>;
+}
+
 export interface TelegramQueuedOutboundAttachmentView {
   path: string;
   fileName: string;
@@ -90,9 +109,71 @@ function formatTelegramOutboundAttachmentSizeLimitError(
   return path ? `${message}: ${path}` : message;
 }
 
-function formatTelegramOutboundAttachmentToolResultText(count: number): string {
+function formatTelegramOutboundAttachmentToolResultText(
+  count: number,
+  mode: "queued" | "sent" = "queued",
+): string {
   // Pi's compact tool rows need an empty first line to visually separate header and result
-  return ["", `Queued ${count} Telegram attachment(s).`].join("\n");
+  const verb = mode === "queued" ? "Queued" : "Sent";
+  return ["", `${verb} ${count} Telegram attachment(s).`].join("\n");
+}
+
+function formatTelegramOutboundMessageToolResultText(chatId: number): string {
+  return ["", `Sent Telegram message to ${chatId}.`].join("\n");
+}
+
+function assertTelegramDirectDeliveryAllowed(
+  canSendDirect: (() => boolean) | undefined,
+): void {
+  if (canSendDirect?.()) return;
+  throw new Error(
+    "Telegram direct delivery requires this π instance to own /telegram-connect",
+  );
+}
+
+function resolveTelegramOutboundChatId(options: {
+  chatId?: number;
+  getDefaultChatId?: () => number | undefined;
+}): number {
+  const chatId = options.chatId ?? options.getDefaultChatId?.();
+  if (chatId === undefined) {
+    throw new Error(
+      "Telegram chat_id is required when no paired/default Telegram chat is available",
+    );
+  }
+  return chatId;
+}
+
+async function buildTelegramOutboundAttachmentViews(options: {
+  paths: string[];
+  maxAttachmentSizeBytes?: number;
+  statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
+}): Promise<TelegramQueuedOutboundAttachmentView[]> {
+  const pendingAttachments: TelegramQueuedOutboundAttachmentView[] = [];
+  for (const inputPath of options.paths) {
+    const stats = await (options.statPath ?? stat)(inputPath);
+    if (!stats.isFile()) {
+      throw new Error(`Not a file: ${inputPath}`);
+    }
+    if (
+      options.maxAttachmentSizeBytes !== undefined &&
+      stats.size !== undefined &&
+      stats.size > options.maxAttachmentSizeBytes
+    ) {
+      throw new Error(
+        formatTelegramOutboundAttachmentSizeLimitError(
+          stats.size,
+          options.maxAttachmentSizeBytes,
+          inputPath,
+        ),
+      );
+    }
+    pendingAttachments.push({
+      path: inputPath,
+      fileName: basename(inputPath),
+    });
+  }
+  return pendingAttachments;
 }
 
 export function registerTelegramOutboundAttachmentTool(
@@ -107,24 +188,43 @@ export function registerTelegramOutboundAttachmentTool(
     name: "telegram_attach",
     label: "Telegram Attach",
     description:
-      "Queue one or more local files to be sent with the next Telegram reply.",
-    promptSnippet: "Queue local files to be sent with the next Telegram reply.",
+      "Queue one or more local files for the active Telegram reply, or send them immediately to Telegram when no Telegram turn is active.",
+    promptSnippet:
+      "Queue files for the active Telegram reply; outside Telegram turns, send files directly to Telegram.",
     promptGuidelines: [
       "When handling a [telegram] message and the user asked for a file or generated artifact, call telegram_attach with the local path instead of only mentioning the path in text.",
+      "When a local/TUI user explicitly asks to send a generated file to Telegram, telegram_attach can deliver it to the paired/default Telegram chat even without an active Telegram turn.",
     ],
     parameters: Type.Object({
       paths: Type.Array(
         Type.String({ description: "Local file path to attach" }),
         { minItems: 1, maxItems: maxAttachmentsPerTurn },
       ),
+      chat_id: Type.Optional(
+        Type.Number({
+          description:
+            "Optional Telegram chat id for immediate delivery when no Telegram turn is active",
+        }),
+      ),
+      caption: Type.Optional(
+        Type.String({
+          description:
+            "Optional caption for immediate delivery; ignored when queued for an active turn",
+        }),
+      ),
     }),
     async execute(_toolCallId, params) {
       try {
         return await queueTelegramOutboundAttachments({
           activeTurn: deps.getActiveTurn(),
           paths: params.paths,
+          chatId: params.chat_id,
+          caption: params.caption,
           maxAttachmentsPerTurn,
           maxAttachmentSizeBytes,
+          sendMultipart: deps.sendMultipart,
+          getDefaultChatId: deps.getDefaultChatId,
+          canSendDirect: deps.canSendDirect,
           statPath: deps.statPath,
         });
       } catch (error) {
@@ -138,6 +238,46 @@ export function registerTelegramOutboundAttachmentTool(
   });
 }
 
+export function registerTelegramOutboundMessageTool(
+  pi: ExtensionAPI,
+  deps: TelegramOutboundMessageToolRegistrationDeps,
+): void {
+  pi.registerTool({
+    name: "telegram_message",
+    label: "Telegram Message",
+    description:
+      "Send a Markdown text message directly to the paired/default Telegram chat or an explicit chat_id. Hidden telegram_button comments in the text become attached inline prompt buttons.",
+    promptSnippet:
+      "Send direct Telegram Markdown text when the user explicitly asks for Telegram delivery outside the normal reply flow.",
+    promptGuidelines: [
+      "Use telegram_message only when the user explicitly asks to send a message to Telegram from the local/TUI side, or names a concrete Telegram delivery target.",
+      "Add buttons by embedding the same top-level telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.",
+      "Do not use this tool for ordinary Telegram-originated replies; answer normally so the bridge can deliver the active turn reply.",
+    ],
+    parameters: Type.Object({
+      text: Type.String({ description: "Message text to send" }),
+      chat_id: Type.Optional(
+        Type.Number({ description: "Optional Telegram chat id" }),
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      try {
+        return await sendTelegramOutboundMessage({
+          text: params.text,
+          chatId: params.chat_id,
+          getDefaultChatId: deps.getDefaultChatId,
+          canSendDirect: deps.canSendDirect,
+          planMessage: deps.planMessage,
+          sendMarkdownMessage: deps.sendMarkdownMessage,
+        });
+      } catch (error) {
+        deps.recordRuntimeEvent?.("message", error, { phase: "direct" });
+        throw error;
+      }
+    },
+  });
+}
+
 export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
   sendMultipart: (
     method: string,
@@ -163,14 +303,32 @@ export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
 export async function queueTelegramOutboundAttachments(options: {
   activeTurn: TelegramOutboundAttachmentQueueTargetView | undefined;
   paths: string[];
+  chatId?: number;
+  caption?: string;
   maxAttachmentsPerTurn: number;
   maxAttachmentSizeBytes?: number;
+  sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+  getDefaultChatId?: () => number | undefined;
+  canSendDirect?: () => boolean;
   statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
 }): Promise<TelegramOutboundAttachmentToolResult> {
   if (!options.activeTurn) {
-    throw new Error(
-      "telegram_attach can only be used while replying to an active Telegram turn",
-    );
+    if (!options.sendMultipart) {
+      throw new Error(
+        "telegram_attach can only queue files while replying to an active Telegram turn; provide Telegram send ports for immediate delivery",
+      );
+    }
+    return sendTelegramOutboundFiles({
+      paths: options.paths,
+      chatId: options.chatId,
+      caption: options.caption,
+      maxAttachmentsPerTurn: options.maxAttachmentsPerTurn,
+      maxAttachmentSizeBytes: options.maxAttachmentSizeBytes,
+      sendMultipart: options.sendMultipart,
+      getDefaultChatId: options.getDefaultChatId,
+      canSendDirect: options.canSendDirect,
+      statPath: options.statPath,
+    });
   }
   if (
     options.activeTurn.queuedAttachments.length + options.paths.length >
@@ -180,30 +338,11 @@ export async function queueTelegramOutboundAttachments(options: {
       `Attachment limit reached (${options.maxAttachmentsPerTurn})`,
     );
   }
-  const pendingAttachments: TelegramQueuedOutboundAttachmentView[] = [];
-  for (const inputPath of options.paths) {
-    const stats = await (options.statPath ?? stat)(inputPath);
-    if (!stats.isFile()) {
-      throw new Error(`Not a file: ${inputPath}`);
-    }
-    if (
-      options.maxAttachmentSizeBytes !== undefined &&
-      stats.size !== undefined &&
-      stats.size > options.maxAttachmentSizeBytes
-    ) {
-      throw new Error(
-        formatTelegramOutboundAttachmentSizeLimitError(
-          stats.size,
-          options.maxAttachmentSizeBytes,
-          inputPath,
-        ),
-      );
-    }
-    pendingAttachments.push({
-      path: inputPath,
-      fileName: basename(inputPath),
-    });
-  }
+  const pendingAttachments = await buildTelegramOutboundAttachmentViews({
+    paths: options.paths,
+    maxAttachmentSizeBytes: options.maxAttachmentSizeBytes,
+    statPath: options.statPath,
+  });
   options.activeTurn.queuedAttachments.push(...pendingAttachments);
   const added = pendingAttachments.map((attachment) => attachment.path);
   return {
@@ -217,6 +356,89 @@ export async function queueTelegramOutboundAttachments(options: {
   };
 }
 
+export async function sendTelegramOutboundMessage(options: {
+  text: string;
+  chatId?: number;
+  getDefaultChatId?: () => number | undefined;
+  canSendDirect: () => boolean;
+  planMessage: (markdown: string) => TelegramOutboundMessagePlan;
+  sendMarkdownMessage: (
+    chatId: number,
+    markdown: string,
+    options?: { replyMarkup?: unknown },
+  ) => Promise<number | undefined>;
+}): Promise<{
+  content: Array<{ type: "text"; text: string }>;
+  details: { chatId: number; messageId?: number };
+}> {
+  assertTelegramDirectDeliveryAllowed(options.canSendDirect);
+  const chatId = resolveTelegramOutboundChatId({
+    chatId: options.chatId,
+    getDefaultChatId: options.getDefaultChatId,
+  });
+  const plan = options.planMessage(options.text);
+  const messageId = await options.sendMarkdownMessage(chatId, plan.markdown, {
+    replyMarkup: plan.replyMarkup,
+  });
+  return {
+    content: [{ type: "text", text: formatTelegramOutboundMessageToolResultText(chatId) }],
+    details: { chatId, messageId },
+  };
+}
+
+export async function sendTelegramOutboundFiles(options: {
+  paths: string[];
+  chatId?: number;
+  caption?: string;
+  maxAttachmentsPerTurn: number;
+  maxAttachmentSizeBytes?: number;
+  sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+  getDefaultChatId?: () => number | undefined;
+  canSendDirect?: () => boolean;
+  statPath?: (path: string) => Promise<{ isFile(): boolean; size?: number }>;
+}): Promise<TelegramOutboundAttachmentToolResult & { details: { paths: string[]; chatId: number } }> {
+  assertTelegramDirectDeliveryAllowed(options.canSendDirect);
+  if (options.paths.length > options.maxAttachmentsPerTurn) {
+    throw new Error(
+      `Attachment limit reached (${options.maxAttachmentsPerTurn})`,
+    );
+  }
+  const chatId = resolveTelegramOutboundChatId({
+    chatId: options.chatId,
+    getDefaultChatId: options.getDefaultChatId,
+  });
+  const pendingAttachments = await buildTelegramOutboundAttachmentViews({
+    paths: options.paths,
+    maxAttachmentSizeBytes: options.maxAttachmentSizeBytes,
+    statPath: options.statPath,
+  });
+  for (const [index, attachment] of pendingAttachments.entries()) {
+    const isPhoto = isTelegramOutboundPhotoAttachmentPath(attachment.path);
+    const method = isPhoto ? "sendPhoto" : "sendDocument";
+    const fieldName = isPhoto ? "photo" : "document";
+    await options.sendMultipart(
+      method,
+      {
+        chat_id: String(chatId),
+        ...(options.caption && index === 0 ? { caption: options.caption } : {}),
+      },
+      fieldName,
+      attachment.path,
+      attachment.fileName,
+    );
+  }
+  const added = pendingAttachments.map((attachment) => attachment.path);
+  return {
+    content: [
+      {
+        type: "text",
+        text: formatTelegramOutboundAttachmentToolResultText(added.length, "sent"),
+      },
+    ],
+    details: { paths: added, chatId },
+  };
+}
+
 export function createTelegramQueuedOutboundAttachmentSender(
   deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ) {

package/lib/prompts.ts

@@ -23,13 +23,13 @@ Telegram-visible output:
 - Telegram is often phone-width; keep tables, dense list items, and compact text blocks at or below 37 visible cells when possible.
 - Count display width, not raw characters: emoji and some glyphs are wide, so prefer shorter labels when unsure.
 - Wide monospace blocks can become unreadable on mobile; use them only when structure or literal code requires them.
-- For requested/generated files, call tool \`telegram_attach(local_path)\`; mentioning a local path in text does not send it.
+- For requested/generated files, call \`telegram_attach(local_path)\`; during Telegram turns it attaches files to the active reply, and during explicit local/TUI Telegram-delivery requests it sends files directly to the paired/default chat or an explicit \`chat_id\`. If a local/TUI user explicitly asks to send a text message to Telegram, use \`telegram_message\` with Markdown text; embed the same top-level \`telegram_button\` comments when inline prompt buttons are needed, because Telegram buttons must belong to a message. Direct local/TUI Telegram delivery requires this π instance to own \`/telegram-connect\`; if ownership is elsewhere, connect/take over first instead of bypassing the lock.
 
 Native outbound actions:
-- Use top-level column-zero hidden Markdown comments outside code, quotes, and lists; the bridge handles them after agent_end, so do not call or register transport/TTS/text-to-OGG tools.
+- Use normal Markdown for visible text. Use top-level column-zero hidden Markdown comments outside code, quotes, and lists only for native actions; the bridge strips them after agent_end and turns them into Telegram-native artifacts/reply_markup. Do not render button JSON, do not invent standalone button tools, and do not call/register transport/TTS/text-to-OGG tools for ordinary Telegram-turn voice/buttons.
 - \`telegram_voice\`: text is synthesized by the registered voice synthesis provider and delivered by pi-telegram. Use body text for multiline voice, \`<!-- telegram_voice text="Short summary" -->\` for explicit one-line voice, or \`<!-- telegram_voice: Short summary -->\` for one-line voice with no attributes. A companion summary is optional, no specific summary format is required. Keep it TTS-friendly; avoid raw Markdown, code, formulas, tables, or long lists.
-- \`telegram_button\`: callback prompt is routed back as a normal Telegram turn. Use \`<!-- telegram_button: OK -->\` when prompt equals label, \`<!-- telegram_button label=Continue prompt="Continue with the current plan." -->\` for one-line prompts, or body form \`<!-- telegram_button label="Show risks"\nList the main risks first.\n-->\` for multiline prompts.
-- If only hidden action comments would remain, add visible parent text like "Choose one:".
+- \`telegram_button\`: callback prompt is routed back as a normal Telegram turn. Use \`<!-- telegram_button: OK -->\` when prompt equals label, \`<!-- telegram_button label=Continue prompt="Continue with the current plan." -->\` for one-line prompts, or body form \`<!-- telegram_button label="Show risks"\nList the main risks first.\n-->\` for multiline prompts. Do not put button comments inline after visible text, inside code fences, block quotes, lists, or indented examples; those are literal Markdown, not buttons.
+- If only hidden action comments would remain, add visible parent text like "Choose one:" so Telegram has a message to attach buttons to.
 `;
 
 export function buildTelegramBridgeSystemPrompt(options: {

package/lib/queue.ts

@@ -242,12 +242,12 @@ export function partitionTelegramQueueItemsForHistory<TContext = unknown>(
 
 export function planTelegramPromptEnqueue<TContext = unknown>(
   items: TelegramQueueItem<TContext>[],
-  preserveQueuedTurnsAsHistory: boolean,
+  foldQueuedPromptsIntoHistory: boolean,
 ): {
   historyTurns: PendingTelegramTurn[];
   remainingItems: TelegramQueueItem<TContext>[];
 } {
-  if (!preserveQueuedTurnsAsHistory) {
+  if (!foldQueuedPromptsIntoHistory) {
     return { historyTurns: [], remainingItems: items };
   }
   return partitionTelegramQueueItemsForHistory(items);
@@ -512,11 +512,11 @@ export function planNextTelegramQueueAction<TContext = unknown>(
 export function shouldDispatchAfterTelegramAgentEnd(options: {
   hasTurn: boolean;
   stopReason?: string;
-  preserveQueuedTurnsAsHistory: boolean;
+  foldQueuedPromptsIntoHistory: boolean;
 }): boolean {
   if (!options.hasTurn) return true;
   if (options.stopReason === "aborted") {
-    return !options.preserveQueuedTurnsAsHistory;
+    return !options.foldQueuedPromptsIntoHistory;
   }
   return true;
 }
@@ -529,6 +529,7 @@ export interface TelegramAgentStartPlan<TContext = unknown> {
   shouldResetPendingModelSwitch: boolean;
   shouldResetToolExecutions: boolean;
   shouldClearDispatchPending: boolean;
+  shouldClearAbortHistory: boolean;
 }
 
 export interface TelegramAgentStartRuntimeDeps<
@@ -542,6 +543,7 @@ export interface TelegramAgentStartRuntimeDeps<
   resetPendingModelSwitch: () => void;
   setQueuedItems: (items: TelegramQueueItem<TContext>[]) => void;
   clearDispatchPending: () => void;
+  setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   setActiveTurn: (turn: TTurn) => void;
   createPreviewState: () => void;
   startTypingLoop: () => void;
@@ -560,6 +562,7 @@ export interface TelegramAgentStartHookRuntimeDeps<
   resetPendingModelSwitch: () => void;
   setQueuedItems: (items: TelegramQueueItem<TContext>[]) => void;
   clearDispatchPending: () => void;
+  setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   setActiveTurn: (turn: TTurn) => void;
   createPreviewState: () => void;
   startTypingLoop: (ctx: TContext) => void;
@@ -598,6 +601,8 @@ export function buildTelegramAgentStartPlan<TContext = unknown>(options: {
       shouldResetPendingModelSwitch: true,
       shouldResetToolExecutions: true,
       shouldClearDispatchPending: options.hasPendingDispatch,
+      shouldClearAbortHistory:
+        !options.hasActiveTurn && !options.hasPendingDispatch,
     };
   }
   const nextDispatch = consumeDispatchedTelegramPrompt(
@@ -610,6 +615,7 @@ export function buildTelegramAgentStartPlan<TContext = unknown>(options: {
     shouldResetPendingModelSwitch: true,
     shouldResetToolExecutions: true,
     shouldClearDispatchPending: options.hasPendingDispatch,
+    shouldClearAbortHistory: false,
   };
 }
 
@@ -624,6 +630,9 @@ export function handleTelegramAgentStartRuntime<
   });
   if (startPlan.shouldResetToolExecutions) deps.resetToolExecutions();
   if (startPlan.shouldResetPendingModelSwitch) deps.resetPendingModelSwitch();
+  if (startPlan.shouldClearAbortHistory) {
+    deps.setFoldQueuedPromptsIntoHistory(false);
+  }
   deps.setQueuedItems(startPlan.remainingItems);
   if (startPlan.shouldClearDispatchPending) deps.clearDispatchPending();
   if (startPlan.activeTurn) {
@@ -651,6 +660,7 @@ export function createTelegramAgentStartHook<
       resetPendingModelSwitch: deps.resetPendingModelSwitch,
       setQueuedItems: deps.setQueuedItems,
       clearDispatchPending: deps.clearDispatchPending,
+      setFoldQueuedPromptsIntoHistory: deps.setFoldQueuedPromptsIntoHistory,
       setActiveTurn: deps.setActiveTurn,
       createPreviewState: deps.createPreviewState,
       startTypingLoop: () => deps.startTypingLoop(ctx),
@@ -791,10 +801,10 @@ export interface TelegramAgentEndRuntimeDeps<
 > {
   turn: TTurn | undefined;
   assistant: TelegramAgentEndAssistantResult;
-  preserveQueuedTurnsAsHistory: boolean;
+  foldQueuedPromptsIntoHistory: boolean;
   resetRuntimeState: () => void;
+  waitForTypingIdle?: () => Promise<void>;
   updateStatus: () => void;
-  isCurrentOwner?: () => boolean;
   dispatchNextQueuedTelegramTurn: () => void;
   clearPreview: (chatId: number) => Promise<void>;
   setPreviewPendingText: (text: string) => void;
@@ -849,10 +859,10 @@ export interface TelegramAgentEndHookRuntimeDeps<
   extractAssistant: (
     messages: readonly TMessage[],
   ) => TelegramAgentEndAssistantResult;
-  getPreserveQueuedTurnsAsHistory: () => boolean;
+  getFoldQueuedPromptsIntoHistory: () => boolean;
   resetRuntimeState: () => void;
+  waitForTypingIdle?: () => Promise<void>;
   updateStatus: (ctx: TContext) => void;
-  isCurrentOwner?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestDeferredDispatchNextQueuedTelegramTurn: (
     dispatch: (ctx: TContext) => void,
@@ -890,12 +900,12 @@ export function buildTelegramAgentEndPlan(options: {
   stopReason?: string;
   hasFinalText: boolean;
   hasQueuedAttachments: boolean;
-  preserveQueuedTurnsAsHistory: boolean;
+  foldQueuedPromptsIntoHistory: boolean;
 }): TelegramAgentEndPlan {
   const shouldDispatchNext = shouldDispatchAfterTelegramAgentEnd({
     hasTurn: options.hasTurn,
     stopReason: options.stopReason,
-    preserveQueuedTurnsAsHistory: options.preserveQueuedTurnsAsHistory,
+    foldQueuedPromptsIntoHistory: options.foldQueuedPromptsIntoHistory,
   });
   if (!options.hasTurn) {
     return {
@@ -974,12 +984,10 @@ export function createTelegramAgentEndHook<
       turn,
       assistant:
         turn || proactiveEnabled ? deps.extractAssistant(event.messages) : {},
-      preserveQueuedTurnsAsHistory: deps.getPreserveQueuedTurnsAsHistory(),
+      foldQueuedPromptsIntoHistory: deps.getFoldQueuedPromptsIntoHistory(),
       resetRuntimeState: deps.resetRuntimeState,
+      waitForTypingIdle: deps.waitForTypingIdle,
       updateStatus: () => deps.updateStatus(ctx),
-      isCurrentOwner: deps.isCurrentOwner
-        ? () => deps.isCurrentOwner?.(ctx) ?? false
-        : undefined,
       dispatchNextQueuedTelegramTurn: () => {
         deps.requestDeferredDispatchNextQueuedTelegramTurn(
           deps.dispatchNextQueuedTelegramTurn,
@@ -1039,17 +1047,14 @@ export async function handleTelegramAgentEndRuntime<
     !!outboundReply?.voiceText || !!outboundReply?.voiceReplies?.length;
   const replyMarkup = outboundReply?.replyMarkup;
   deps.resetRuntimeState();
+  await deps.waitForTypingIdle?.();
   deps.updateStatus();
-  if (deps.isCurrentOwner && !deps.isCurrentOwner()) {
-    if (turn) await deps.clearPreview(turn.chatId);
-    return;
-  }
   const endPlan = buildTelegramAgentEndPlan({
     hasTurn: !!turn,
     stopReason: assistant.stopReason,
     hasFinalText: !!finalText || hasOutboundArtifacts,
     hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
-    preserveQueuedTurnsAsHistory: deps.preserveQueuedTurnsAsHistory,
+    foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
   });
   if (!turn) {
     if (
@@ -1072,10 +1077,6 @@ export async function handleTelegramAgentEndRuntime<
     return;
   }
   if (turn.guestQueryId) {
-    if (deps.isCurrentOwner && !deps.isCurrentOwner()) {
-      if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
-      return;
-    }
     if (assistant.errorMessage) {
       await deps.answerGuestQuery?.(
         turn.guestQueryId,
@@ -1199,7 +1200,7 @@ export interface TelegramSessionShutdownState<TQueueItem> {
   pendingTelegramModelSwitch: undefined;
   telegramTurnDispatchPending: boolean;
   compactionInProgress: boolean;
-  preserveQueuedTurnsAsHistory: boolean;
+  foldQueuedPromptsIntoHistory: boolean;
 }
 
 export interface TelegramSessionRuntimeCounterState {
@@ -1212,7 +1213,7 @@ export interface TelegramSessionRuntimeFlagState {
   activeTelegramToolExecutions?: number;
   telegramTurnDispatchPending?: boolean;
   compactionInProgress?: boolean;
-  preserveQueuedTurnsAsHistory?: boolean;
+  foldQueuedPromptsIntoHistory?: boolean;
 }
 
 export interface TelegramSessionStateApplierDeps<TQueueItem, TModel> {
@@ -1342,8 +1343,8 @@ export interface TelegramPromptEnqueueRuntimeDeps<
   TMessage,
   TContext = unknown,
 > extends TelegramQueueStore<TContext> {
-  getPreserveQueuedTurnsAsHistory: () => boolean;
-  setPreserveQueuedTurnsAsHistory: (preserve: boolean) => void;
+  getFoldQueuedPromptsIntoHistory: () => boolean;
+  setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   createTurn: (
     messages: TMessage[],
     historyTurns: PendingTelegramTurn[],
@@ -1356,8 +1357,8 @@ export interface TelegramPromptEnqueueControllerDeps<
   TMessage,
   TContext = unknown,
 > extends TelegramQueueStore<TContext> {
-  getPreserveQueuedTurnsAsHistory: () => boolean;
-  setPreserveQueuedTurnsAsHistory: (preserve: boolean) => void;
+  getFoldQueuedPromptsIntoHistory: () => boolean;
+  setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   createTurn: (
     messages: TMessage[],
     historyTurns: PendingTelegramTurn[],
@@ -1406,7 +1407,7 @@ export function buildTelegramSessionShutdownState<
     pendingTelegramModelSwitch: undefined,
     telegramTurnDispatchPending: false,
     compactionInProgress: false,
-    preserveQueuedTurnsAsHistory: false,
+    foldQueuedPromptsIntoHistory: false,
   };
 }
 
@@ -1654,9 +1655,9 @@ export async function enqueueTelegramPromptTurnRuntime<
 ): Promise<void> {
   const enqueuePlan = planTelegramPromptEnqueue(
     deps.getQueuedItems(),
-    deps.getPreserveQueuedTurnsAsHistory(),
+    deps.getFoldQueuedPromptsIntoHistory(),
   );
-  deps.setPreserveQueuedTurnsAsHistory(false);
+  deps.setFoldQueuedPromptsIntoHistory(false);
   const turn = await deps.createTurn(messages, enqueuePlan.historyTurns);
   deps.setQueuedItems(
     appendTelegramQueueItem(enqueuePlan.remainingItems, turn),

package/lib/routing.ts

@@ -342,7 +342,7 @@ export function createTelegramInboundRouteRuntime<
     message: TMessage,
     ctx: TContext,
   ): Promise<void> => {
-    deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory(false);
+    deps.bridgeRuntime.lifecycle.setFoldQueuedPromptsIntoHistory(false);
     const continueMessage = {
       ...message,
       text: "continue",
@@ -374,8 +374,8 @@ export function createTelegramInboundRouteRuntime<
     clearPendingModelSwitch: deps.modelSwitchController.clearPendingSwitch,
     hasQueuedTelegramItems: deps.telegramQueueStore.hasQueuedItems,
     clearQueuedTelegramItems: deps.queueMutationRuntime.clear,
-    setPreserveQueuedTurnsAsHistory:
-      deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
+    setFoldQueuedPromptsIntoHistory:
+      deps.bridgeRuntime.lifecycle.setFoldQueuedPromptsIntoHistory,
     abortCurrentTurn: deps.bridgeRuntime.abort.abortTurn,
     isIdle: deps.isIdle,
     hasPendingMessages: deps.hasPendingMessages,
@@ -420,10 +420,10 @@ export function createTelegramInboundRouteRuntime<
     TContext
   >({
     ...deps.telegramQueueStore,
-    getPreserveQueuedTurnsAsHistory:
-      deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory,
-    setPreserveQueuedTurnsAsHistory:
-      deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
+    getFoldQueuedPromptsIntoHistory:
+      deps.bridgeRuntime.lifecycle.shouldFoldQueuedPromptsIntoHistory,
+    setFoldQueuedPromptsIntoHistory:
+      deps.bridgeRuntime.lifecycle.setFoldQueuedPromptsIntoHistory,
     createTurn: promptTurnBuilder,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,