grok-telegram-bot 2.4.0 → 2.5.0

package/src/bot/handlers/voice.ts

@@ -14,8 +14,16 @@ import { extractReplyContext } from "../reply-context.js";
 
 const log = createLogger("voice");
 
+type VoiceMediaKind = "voice" | "audio" | "video_note";
+
 export function registerVoice(bot: Bot, deps: BotDeps): void {
-  const handle = async (ctx: Context, fileId: string, mime: string, name: string): Promise<void> => {
+  const handle = async (
+    ctx: Context,
+    fileId: string,
+    mime: string,
+    name: string,
+    mediaKind: VoiceMediaKind,
+  ): Promise<void> => {
     const chatId = ctx.chat!.id;
     if (deps.wizard.isActive(chatId)) {
       await ctx.reply("Finish or /cancel the task wizard before sending voice.");
@@ -36,11 +44,41 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
         await ctx.reply("\u{1F399} I couldn't make out any speech.");
         return;
       }
-      await ctx.reply(`\u{1F399} \u201C${text}\u201D`);
-      const rt = deps.registry.get(chatId);
+      const { resolveScope } = await import("../scope.js");
+      const { adoptUserPrompt } = await import("../prompt-anchor.js");
+      const scope = resolveScope(ctx, deps);
       const quoted = extractReplyContext(ctx);
-      const outcome = await rt.submit(textPrompt(text, ctx.message?.message_id, quoted));
-      if (outcome === "queued") await ctx.reply("\u{1F4E5} Queued \u2014 will run after the current task.");
+      const userMsgId = ctx.message?.message_id;
+      const media =
+        mediaKind === "video_note"
+          ? [{ type: "video_note" as const, fileId }]
+          : mediaKind === "voice"
+            ? [{ type: "voice" as const, fileId }]
+            : [{ type: "audio" as const, fileId, fileName: name }];
+      const anchor = await adoptUserPrompt(deps.api, {
+        chatId,
+        text: `\u201C${text}\u201D`,
+        userMessageIds: userMsgId !== undefined ? [userMsgId] : [],
+        messageThreadId: scope.threadExtra.message_thread_id,
+        projectName: scope.rt.projectName,
+        prefix: "\u{1F399} Voice",
+        media,
+      });
+      const outcome = await scope.rt.submit(
+        textPrompt(text, anchor?.replyTo ?? userMsgId, quoted, {
+          promptId: anchor?.promptId,
+        }),
+      );
+      if (outcome === "queued") {
+        const extra: Record<string, unknown> = { ...scope.threadExtra };
+        if (anchor?.replyTo !== undefined) {
+          extra.reply_parameters = {
+            message_id: anchor.replyTo,
+            allow_sending_without_reply: true,
+          };
+        }
+        await ctx.reply("\u{1F4E5} Queued \u2014 will run after the current task.", extra);
+      }
     } catch (e) {
       log.warn("voice failed:", (e as Error).message);
       await ctx.reply(`\u274C Voice transcription failed: ${(e as Error).message}`);
@@ -48,7 +86,13 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
   };
 
   bot.on("message:voice", (ctx) =>
-    handle(ctx, ctx.message.voice.file_id, ctx.message.voice.mime_type || "audio/ogg", "voice.ogg"),
+    handle(
+      ctx,
+      ctx.message.voice.file_id,
+      ctx.message.voice.mime_type || "audio/ogg",
+      "voice.ogg",
+      "voice",
+    ),
   );
   bot.on("message:audio", (ctx) =>
     handle(
@@ -56,10 +100,11 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
       ctx.message.audio.file_id,
       ctx.message.audio.mime_type || "audio/mpeg",
       ctx.message.audio.file_name || "audio.mp3",
+      "audio",
     ),
   );
   bot.on("message:video_note", (ctx) =>
-    handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4"),
+    handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4", "video_note"),
   );
 }
 

package/src/bot/image-return.ts

@@ -129,6 +129,8 @@ export interface SendImagesOptions {
   max: number;
   /** Optional Telegram message id to thread replies under. */
   replyTo?: number;
+  /** Forum topic — required so agent images land in the right topic. */
+  messageThreadId?: number;
 }
 
 /** Send the valid, fresh, not-yet-sent images as documents. Returns how many were sent. */
@@ -139,10 +141,11 @@ export async function sendImages(
   opts: SendImagesOptions,
 ): Promise<number> {
   let sent = 0;
-  const replyExtra =
-    opts.replyTo !== undefined
-      ? { reply_parameters: { message_id: opts.replyTo, allow_sending_without_reply: true } }
-      : {};
+  const extra: Record<string, unknown> = {};
+  if (opts.replyTo !== undefined) {
+    extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
+  }
+  if (opts.messageThreadId !== undefined) extra.message_thread_id = opts.messageThreadId;
   for (const path of paths) {
     if (sent >= opts.max) break;
     if (opts.already.has(path)) continue;
@@ -161,7 +164,7 @@ export async function sendImages(
       const file = new InputFile(path, basename(path));
       await api.sendDocument(chatId, file, {
         caption: basename(path),
-        ...replyExtra,
+        ...extra,
       });
       sent++;
       log.debug(`sent document ${path}`);

package/src/bot/menu/ephemeral.ts

@@ -95,11 +95,21 @@ export class Ephemeral {
   async reply(ctx: Context, text: string, extra: Record<string, unknown> = {}): Promise<number | undefined> {
     const chatId = ctx.chat?.id;
     if (chatId === undefined) return undefined;
+    // Stay in the forum topic when the trigger message was in a thread.
+    const msg = ctx.message ?? ctx.callbackQuery?.message;
+    const threadId =
+      msg && "message_thread_id" in msg
+        ? (msg as { message_thread_id?: number }).message_thread_id
+        : undefined;
+    const merged =
+      threadId !== undefined && extra.message_thread_id === undefined
+        ? { ...extra, message_thread_id: threadId }
+        : extra;
     return this.serialize(chatId, async () => {
       try {
-        const msg = await ctx.reply(text, extra);
-        this.remember(chatId, msg.message_id);
-        return msg.message_id;
+        const m = await ctx.reply(text, merged);
+        this.remember(chatId, m.message_id);
+        return m.message_id;
       } catch {
         return undefined;
       }

package/src/bot/menu/keyboard.ts

@@ -1,32 +1,71 @@
 /**
  * Menu surfaces:
- *  - a tiny PERSISTENT bar (☰ Menu · 🧭 Running · ⏹ Stop) — minimal footprint;
- *  - a full, organized INLINE menu opened on demand (and hideable).
- * Live state (project/model/reasoning/context) lives in the pinned panel,
- * so the bar stays clean. (Agent picker removed — Grok has no useful headless
- * agent switch; plan mode is entered automatically when the agent judges the task complex.)
+ *  - PERSISTENT bar (reply keyboard): ☰ Menu · 🆕 New session / 🧭 Running · ⏹ Stop
+ *    — primary place for New session in private chats (not the inline Menu message).
+ *  - INLINE menu message (opened via ☰ Menu or /menu) — settings & navigation.
+ *    Forum topics: reply keyboards are unreliable, so New stays on the topic inline menu.
+ * Live state lives in the pinned status panel so the bar stays clean.
  */
 import { InlineKeyboard, Keyboard } from "grammy";
 
 export const MENU_BTN = "\u2630 Menu"; // ☰
+/** Persistent bar + forum topic control — brand-new session (same as /new). */
+export const NEW_BTN = "\u{1F195} New session";
 export const RUNNING_BTN = "\u{1F9ED} Running";
 export const STOP_BTN = "\u23F9 Stop";
-export const BAR_LABELS = [MENU_BTN, RUNNING_BTN, STOP_BTN];
+export const BAR_LABELS = [MENU_BTN, NEW_BTN, RUNNING_BTN, STOP_BTN];
 
-/** The always-visible compact bar. */
+/** The always-visible compact bar (private chats; best-effort in groups). */
 export function compactKeyboard(): Keyboard {
-  return new Keyboard().text(MENU_BTN).text(RUNNING_BTN).text(STOP_BTN).resized().persistent();
+  return new Keyboard()
+    .text(MENU_BTN)
+    .text(NEW_BTN)
+    .row()
+    .text(RUNNING_BTN)
+    .text(STOP_BTN)
+    .resized()
+    .persistent();
 }
 
 /** The full, grouped inline menu (opened via ☰ Menu or /menu). */
-export function mainMenuInline(state: { model: string; reasoning: string }): InlineKeyboard {
+export function mainMenuInline(state: {
+  model: string;
+  reasoning: string;
+  /** Forum topic scope — hide project switch; label topic sessions. */
+  forumTopic?: { name: string; account?: string };
+}): InlineKeyboard {
   const t = (s: string, n: number): string => (s.length > n ? s.slice(0, n - 1) + "\u2026" : s);
-  return new InlineKeyboard()
-    .text("\u{1F4C1} Project", "m:project")
-    .text("\u{1F195} New", "m:new")
+  const kb = new InlineKeyboard();
+
+  if (state.forumTopic) {
+    // Groups/topics: control first (no reliable reply-keyboard bar). New session here.
+    kb.text("\u23F9 Stop", "m:stop")
+      .text("\u{1F9ED} Running", "m:running")
+      .row()
+      .text(NEW_BTN, "m:new")
+      .text("\u{1F5C2} Sessions", "m:sessions")
+      .row()
+      .text(`\u{1F4C1} ${t(state.forumTopic.name, 28)}`, "m:topicinfo")
+      .row()
+      .text("\u{1F4E5} Import session", "m:import")
+      .row()
+      .text(`\u{1F9E9} Model \u00B7 ${t(state.model, 24)}`, "m:model")
+      .row()
+      .text(`\u{1F9E0} Reasoning \u00B7 ${t(state.reasoning, 24)}`, "m:reasoning")
+      .row();
+    if (state.forumTopic.account) {
+      kb.text(`\u{1F465} Account \u00B7 ${t(state.forumTopic.account, 20)}`, "m:accounts").row();
+    }
+    kb.text("\u{1F4CA} Status", "m:status").text("\u2716 Close", "m:close");
+    return kb;
+  }
+
+  // Private chat: New session is on the persistent bar + /new — not on this message.
+  kb.text("\u{1F4C1} Project", "m:project")
+    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
+    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F9ED} Running", "m:running")
-    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
     .text("\u{1F4E5} Import session", "m:import")
     .row()
@@ -41,10 +80,10 @@ export function mainMenuInline(state: { model: string; reasoning: string }): Inl
     .text("\u{1F465} Accounts", "m:accounts")
     .row()
     .text("\u{1F9E9} MCP", "m:mcp")
-    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F6D1} Kill all", "m:killall")
     .row()
     .text("\u2328\uFE0F Show bar", "m:showbar")
     .text("\u{1F648} Hide bar", "m:hidebar")
     .text("\u2716 Close", "m:close");
+  return kb;
 }

package/src/bot/menu/refresh.ts

@@ -4,10 +4,12 @@
  */
 import type { Context } from "grammy";
 import type { BotDeps } from "../deps.js";
+import { resolveScope } from "../scope.js";
 import { compactKeyboard } from "./keyboard.js";
 
 export async function refreshMenu(ctx: Context, deps: BotDeps, text: string): Promise<void> {
   const chatId = ctx.chat!.id;
-  await ctx.reply(text, { reply_markup: compactKeyboard() });
+  const scope = resolveScope(ctx, deps);
+  await ctx.reply(text, { reply_markup: compactKeyboard(), ...scope.threadExtra });
   await deps.statusPanel.refresh(chatId);
 }

package/src/bot/menu/status-panel.ts

@@ -65,13 +65,19 @@ export class StatusPanel {
     if (subagents) activity.push(`\u{1F465} ${subagents}`);
     lines.push(activity.join(SEP));
 
-    // 3b) What is happening now / last summary (same source as Running cards).
-    // Prefer plan one-liner over a redundant tool-step when a plan is active.
-    const comment = rt.planSummary && rt.isBusy ? undefined : rt.cardComment;
+    // 3b) Last user prompt (+ thinking while busy) — same source as Running cards.
+    // When a plan board is already shown above, still surface the user prompt;
+    // skip only a pure thinking second line if plan is active (less noise).
+    const comment = rt.cardComment;
     if (comment) {
-      const icon = rt.isBusy ? "\u23F3" : "\u{1F4AC}";
-      const shown = comment.length > 120 ? `${comment.slice(0, 119)}\u2026` : comment;
-      lines.push(`${icon} ${shown}`);
+      const parts = comment.split("\n").map((l) => l.trim()).filter(Boolean);
+      const hideThinking = !!(rt.planSummary && rt.isBusy);
+      parts.forEach((part, i) => {
+        if (hideThinking && i > 0) return;
+        const icon = i === 0 ? (rt.isBusy ? "\u23F3" : "\u{1F4AC}") : "\u{1F9E0}";
+        const shown = part.length > 250 ? `${part.slice(0, 249)}\u2026` : part;
+        lines.push(`${icon} ${shown}`);
+      });
     }
 
     // 4) Where: project | session | context usage.

package/src/bot/permission-service.ts

@@ -161,6 +161,25 @@ export class PermissionService {
     return this.pending.get(reqId)?.sessionId;
   }
 
+  /**
+   * ACP: when a session is cancelled, all pending permission requests for that
+   * session must complete with `cancelled`. Returns how many were cancelled.
+   * Does not touch other sessions.
+   */
+  cancelForSession(sessionId: string): number {
+    let n = 0;
+    for (const [reqId, p] of [...this.pending.entries()]) {
+      if (p.sessionId !== sessionId) continue;
+      clearTimeout(p.timer);
+      this.pending.delete(reqId);
+      void this.finishPrompt(p, "\u{1F510} (cancelled — turn stopped)");
+      p.resolve({ outcome: { outcome: "cancelled" } });
+      n++;
+    }
+    if (n > 0) log.info(`cancelled ${n} pending permission(s) for session ${sessionId.slice(0, 8)}`);
+    return n;
+  }
+
   /** Unpin (if pinned) and optionally rewrite the prompt message. */
   private async finishPrompt(p: Pending, text?: string): Promise<void> {
     if (p.messageId !== undefined && text) {

package/src/bot/prompt-anchor.ts

@@ -0,0 +1,300 @@
+/**
+ * Prompt anchors & command acks — instant bot feedback while the CLI/ACP warms up.
+ *
+ * When the user sends a prompt we:
+ *   1. post a bot-owned message with the prompt text + `#prompt_<id>`
+ *      (and re-attach any photos/files/voice so media is not lost when the
+ *      user's original is deleted)
+ *   2. best-effort delete the user's original message(s)
+ *   3. thread every AI reply (and Done/error) to that bot message
+ *
+ * Commands use {@link ackCommand}: delete the slash message immediately and
+ * post a short status so the chat never looks dead during slow handlers.
+ */
+import type { Api, Context } from "grammy";
+import { InputMediaBuilder } from "grammy";
+import { createLogger } from "../logger.js";
+import { tagSafe } from "../render/hashtags.js";
+
+const log = createLogger("prompt-anchor");
+
+/** Telegram hard cap for text messages; leave room for prefix + tags. */
+const BODY_BUDGET = 3800;
+/** Telegram caption hard cap on photo/document/audio/video. */
+const CAPTION_BUDGET = 1024;
+
+export type AdoptMediaItem =
+  | { type: "photo"; fileId: string }
+  | { type: "document"; fileId: string; fileName?: string }
+  | { type: "voice"; fileId: string }
+  | { type: "audio"; fileId: string; fileName?: string }
+  | { type: "video"; fileId: string }
+  | { type: "video_note"; fileId: string };
+
+export interface AdoptPromptOpts {
+  chatId: number;
+  /** User prompt body to echo on the anchor (not sent to the agent twice — agent gets original text). */
+  text: string;
+  /** User Telegram message ids to delete after the anchor is posted. */
+  userMessageIds: number[];
+  messageThreadId?: number;
+  projectName?: string;
+  /** Leading emoji/label, e.g. "📝", "📷", "🎤". */
+  prefix?: string;
+  /**
+   * Media from the user's message(s), re-posted via Telegram file_id so the
+   * chat keeps images/files after the original is deleted. Same bot may reuse
+   * file_ids it received.
+   */
+  media?: AdoptMediaItem[];
+}
+
+export interface PromptAnchor {
+  /** Bot message id — use as PromptInput.replyTo. */
+  replyTo: number;
+  /** Short id for `#prompt_<id>` footers. */
+  promptId: string;
+}
+
+/** Short unique id safe for Telegram hashtag bodies. */
+export function newPromptId(): string {
+  const t = Date.now().toString(36);
+  const r = Math.random().toString(36).slice(2, 6);
+  return tagSafe(`${t}${r}`);
+}
+
+export function formatPromptTag(promptId: string): string {
+  return `#prompt_${tagSafe(promptId)}`;
+}
+
+/** Build the plain-text body of a prompt-anchor message (hashtags stay tappable). */
+export function formatPromptAnchorBody(
+  text: string,
+  promptId: string,
+  opts?: { prefix?: string; projectName?: string },
+): string {
+  const prefix = (opts?.prefix ?? "\u{1F4DD}").trim();
+  const body = truncateBody(text.trim() || "(empty)", BODY_BUDGET);
+  const tags = [formatPromptTag(promptId)];
+  if (opts?.projectName?.trim()) {
+    tags.push(`#proj_${tagSafe(opts.projectName)}`);
+  }
+  return `${prefix}\n${body}\n\n${tags.join(" ")}`;
+}
+
+/**
+ * Fit anchor body into a media caption (1024). Prefer keeping the trailing
+ * hashtag line so `#prompt_` stays searchable — never slice tags off the end.
+ */
+export function fitCaption(body: string, max = CAPTION_BUDGET): string {
+  if (body.length <= max) return body;
+  const lines = body.split("\n");
+  const last = (lines[lines.length - 1] ?? "").trim();
+  const tags = last.includes("#prompt_") ? last : "";
+  if (tags) {
+    // Reserve room for "\n…\n\n" + tags; never clip the tag line.
+    const sep = "\n\u2026\n\n";
+    const budget = max - tags.length - sep.length;
+    if (budget > 40) {
+      const cutAt = body.lastIndexOf(tags);
+      const rawHead = (cutAt > 0 ? body.slice(0, cutAt) : body).replace(/\s+$/, "");
+      const head = rawHead.length > budget ? rawHead.slice(0, budget) : rawHead;
+      return `${head}${sep}${tags}`;
+    }
+    // Tags alone almost fill the caption — keep tags only.
+    return tags.length <= max ? tags : tags.slice(0, max - 1) + "\u2026";
+  }
+  return body.slice(0, max - 1) + "\u2026";
+}
+
+/**
+ * Post a bot-owned prompt message (with media when provided), delete the user's
+ * original(s), return ids for threading + tagging. On send failure returns
+ * undefined (caller falls back).
+ */
+export async function adoptUserPrompt(
+  api: Api,
+  opts: AdoptPromptOpts,
+): Promise<PromptAnchor | undefined> {
+  const promptId = newPromptId();
+  const body = formatPromptAnchorBody(opts.text, promptId, {
+    prefix: opts.prefix,
+    projectName: opts.projectName,
+  });
+  const threadExtra: Record<string, unknown> = {
+    disable_notification: true,
+  };
+  if (opts.messageThreadId !== undefined) {
+    threadExtra.message_thread_id = opts.messageThreadId;
+  }
+
+  let replyTo: number;
+  try {
+    const media = (opts.media ?? []).filter((m) => !!m.fileId);
+    if (media.length > 0) {
+      replyTo = await sendAnchorWithMedia(api, opts.chatId, media, body, threadExtra);
+    } else {
+      const msg = await api.sendMessage(opts.chatId, body, threadExtra);
+      replyTo = msg.message_id;
+    }
+  } catch (err) {
+    log.warn(`anchor send failed chat=${opts.chatId}: ${(err as Error).message}`);
+    // Fallback: text-only anchor so threading still works if media re-post fails.
+    try {
+      const msg = await api.sendMessage(opts.chatId, body, threadExtra);
+      replyTo = msg.message_id;
+    } catch (err2) {
+      log.warn(`anchor text fallback failed chat=${opts.chatId}: ${(err2 as Error).message}`);
+      return undefined;
+    }
+  }
+
+  await deleteUserMessages(api, opts.chatId, opts.userMessageIds);
+  return { replyTo, promptId };
+}
+
+/** Re-post user media with caption/tags so files remain in chat history. */
+async function sendAnchorWithMedia(
+  api: Api,
+  chatId: number,
+  media: AdoptMediaItem[],
+  body: string,
+  threadExtra: Record<string, unknown>,
+): Promise<number> {
+  const caption = fitCaption(body);
+  const needsFollowUp = body.length > CAPTION_BUDGET;
+
+  // Photo album: one media group (caption on first only).
+  if (media.length > 1 && media.every((m) => m.type === "photo")) {
+    const group = media.map((m, i) =>
+      i === 0
+        ? InputMediaBuilder.photo(m.fileId, { caption })
+        : InputMediaBuilder.photo(m.fileId),
+    );
+    const msgs = await api.sendMediaGroup(chatId, group, threadExtra);
+    const firstId = msgs[0]?.message_id;
+    if (firstId === undefined) throw new Error("sendMediaGroup returned no messages");
+    if (needsFollowUp) {
+      await api
+        .sendMessage(chatId, body, {
+          ...threadExtra,
+          reply_parameters: { message_id: firstId, allow_sending_without_reply: true },
+        })
+        .catch(() => {});
+    }
+    return firstId;
+  }
+
+  // Single (or primary) media item; extra photos sent as a follow-up group.
+  const primary = media[0]!;
+  const restPhotos = media.slice(1).filter((m): m is Extract<AdoptMediaItem, { type: "photo" }> => m.type === "photo");
+
+  let replyTo: number;
+  const capOpts = { caption, ...threadExtra };
+
+  switch (primary.type) {
+    case "photo": {
+      const msg = await api.sendPhoto(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "document": {
+      const msg = await api.sendDocument(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "voice": {
+      const msg = await api.sendVoice(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "audio": {
+      const msg = await api.sendAudio(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "video": {
+      const msg = await api.sendVideo(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "video_note": {
+      // video_note has no caption — post note then text anchor as reply.
+      const msg = await api.sendVideoNote(chatId, primary.fileId, threadExtra);
+      replyTo = msg.message_id;
+      await api
+        .sendMessage(chatId, body, {
+          ...threadExtra,
+          reply_parameters: { message_id: replyTo, allow_sending_without_reply: true },
+        })
+        .catch(() => {});
+      return replyTo;
+    }
+    default: {
+      const msg = await api.sendMessage(chatId, body, threadExtra);
+      return msg.message_id;
+    }
+  }
+
+  if (restPhotos.length > 0) {
+    const group = restPhotos.map((m) => InputMediaBuilder.photo(m.fileId));
+    await api.sendMediaGroup(chatId, group, threadExtra).catch((e) => {
+      log.debug(`extra photo group failed: ${(e as Error).message}`);
+    });
+  }
+
+  if (needsFollowUp) {
+    await api
+      .sendMessage(chatId, body, {
+        ...threadExtra,
+        reply_parameters: { message_id: replyTo, allow_sending_without_reply: true },
+      })
+      .catch(() => {});
+  }
+
+  return replyTo;
+}
+
+/** Best-effort delete of user messages (private chats may refuse). */
+export async function deleteUserMessages(
+  api: Api,
+  chatId: number,
+  messageIds: number[],
+): Promise<void> {
+  const unique = [...new Set(messageIds.filter((id) => Number.isFinite(id) && id > 0))];
+  await Promise.all(
+    unique.map(async (id) => {
+      try {
+        await api.deleteMessage(chatId, id);
+      } catch {
+        /* no rights / already gone / too old — non-fatal */
+      }
+    }),
+  );
+}
+
+/**
+ * Instant command feedback: delete the user's command and post a bot status.
+ * Fire-and-forget delete so slow work never waits on Telegram cleanup.
+ */
+export async function ackCommand(
+  ctx: Context,
+  text: string,
+  extra: Record<string, unknown> = {},
+): Promise<number | undefined> {
+  void ctx.deleteMessage().catch(() => {});
+  try {
+    const msg = await ctx.reply(text, extra);
+    return msg.message_id;
+  } catch (err) {
+    log.debug(`ackCommand reply failed: ${(err as Error).message}`);
+    return undefined;
+  }
+}
+
+function truncateBody(text: string, max: number): string {
+  if (text.length <= max) return text;
+  const head = Math.floor(max * 0.7);
+  const tail = max - head - 5;
+  return `${text.slice(0, head)}\n\u2026\n${text.slice(-tail)}`;
+}

package/src/bot/prompt-content.ts

@@ -77,6 +77,9 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
     images: inputs.flatMap((i) => i.images),
     resourceLinks: inputs.flatMap((i) => i.resourceLinks ?? []),
     replyTo: inputs.find((i) => i.replyTo !== undefined)?.replyTo,
+    // First prompt's id wins (same rule as replyTo) so merged queue turns keep
+    // one searchable #prompt_ tag threaded to the first anchor.
+    promptId: inputs.find((i) => i.promptId)?.promptId,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
     skipSelfRecheck: skipSelfRecheck || undefined,
   };