@agentprojectcontext/apx 1.31.2 → 1.32.2

package/src/host/daemon/plugins/{telegram.js → telegram/index.js}

@@ -29,22 +29,26 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { TELEGRAM_STATE_PATH, APX_HOME } from "../../../core/config.js";
-import { callEngine } from "../../../core/engines/index.js";
-import { runSuperAgent, isSuperAgentEnabled } from "../super-agent.js";
-import { stripThinking } from "../thinking.js";
-import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "../../../core/messages-store.js";
-import { compactChannelIfNeeded } from "../../../core/memory/index.js";
-import { readAgents } from "../../../core/parser.js";
-import { buildAgentSystem } from "../../../core/agent-system.js";
-import { transcribe as transcribeAudioFile } from "../transcription.js";
-import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "../../../core/identity.js";
-import { registerSender, resolveAllowedTools } from "../../../core/telegram-identity.js";
-import { buildRelationshipBlock } from "../../../core/agent/index.js";
-import { getConfirmationStore as getConfirmStore } from "../../../core/confirmation/pending-store.js";
-import { createTelegramConfirmAdapter } from "../../../core/confirmation/adapters/telegram.js";
-
-const API_BASE = "https://api.telegram.org";
+import { TELEGRAM_STATE_PATH, APX_HOME } from "#core/config/index.js";
+import { callEngine } from "#core/engines/index.js";
+import { runSuperAgent, isSuperAgentEnabled } from "#core/agent/super-agent.js";
+import { stripThinking } from "../../thinking.js";
+import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "#core/stores/messages.js";
+import { compactChannelIfNeeded } from "#core/memory/index.js";
+import { readAgents } from "#core/apc/parser.js";
+import { buildAgentSystem } from "#core/agent/build-agent-system.js";
+import { transcribe as transcribeAudioFile } from "../../transcription.js";
+import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
+import { registerSender, resolveAllowedTools } from "#core/identity/telegram.js";
+import { buildRelationshipBlock } from "#core/agent/index.js";
+import { getConfirmationStore as getConfirmStore } from "#core/confirmation/pending-store.js";
+import { CHANNELS } from "#core/constants/channels.js";
+import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
+import { isLikelyDuplicate } from "#core/util/text-similarity.js";
+import { createTelegramConfirmAdapter } from "#core/confirmation/adapters/telegram.js";
+import * as askFlow from "./ask.js";
+
+// API_BASE re-imported from ./media.js below
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
 // Build the channelMeta passed to the super-agent loop. The prompt template at
@@ -84,159 +88,9 @@ function buildTelegramMeta({ channelName, author, chatId, target, routeToAgent }
   };
 }
 
-// ---------- media sending helpers -------------------------------------------
-
-/**
- * Send a photo to a Telegram chat.
- * @param {string} token     Bot token
- * @param {string|number} chatId  Telegram chat_id
- * @param {string|Buffer} photo   Absolute file path OR Buffer of image data
- * @param {object} [opts]
- * @param {string} [opts.caption]
- * @param {string} [opts.parse_mode]  "HTML" | "Markdown" | "MarkdownV2"
- */
-export async function sendPhoto(token, chatId, photo, { caption, parse_mode } = {}) {
-  const url = `${API_BASE}/bot${token}/sendPhoto`;
-  const form = new FormData();
-  form.append("chat_id", String(chatId));
-  if (caption) form.append("caption", caption);
-  if (parse_mode) form.append("parse_mode", parse_mode);
-
-  if (typeof photo === "string" && photo.startsWith("http")) {
-    // Public URL — send as string
-    form.append("photo", photo);
-  } else {
-    // Local file path or Buffer
-    const buf = Buffer.isBuffer(photo) ? photo : fs.readFileSync(photo);
-    const name = typeof photo === "string" ? path.basename(photo) : "photo.jpg";
-    const blob = new Blob([buf], { type: name.endsWith(".png") ? "image/png" : "image/jpeg" });
-    form.append("photo", blob, name);
-  }
-
-  const res = await fetch(url, { method: "POST", body: form });
-  const json = await res.json();
-  if (!json.ok) throw new Error(`sendPhoto failed: ${json.description || res.status}`);
-  return json.result;
-}
-
-/**
- * Send a voice message (OGG/Opus preferred by Telegram).
- * @param {string} token
- * @param {string|number} chatId
- * @param {string|Buffer} audio  Path or Buffer
- * @param {object} [opts]
- * @param {string} [opts.caption]
- * @param {number} [opts.duration]
- */
-export async function sendVoice(token, chatId, audio, { caption, duration } = {}) {
-  const url = `${API_BASE}/bot${token}/sendVoice`;
-  const form = new FormData();
-  form.append("chat_id", String(chatId));
-  if (caption) form.append("caption", caption);
-  if (duration) form.append("duration", String(duration));
-
-  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
-  const name = typeof audio === "string" ? path.basename(audio) : "voice.ogg";
-  const blob = new Blob([buf], { type: "audio/ogg" });
-  form.append("voice", blob, name);
-
-  const res = await fetch(url, { method: "POST", body: form });
-  const json = await res.json();
-  if (!json.ok) throw new Error(`sendVoice failed: ${json.description || res.status}`);
-  return json.result;
-}
-
-/**
- * Send an audio file (MP3, M4A, etc — shown in Telegram music player).
- * @param {string} token
- * @param {string|number} chatId
- * @param {string|Buffer} audio  Path or Buffer
- * @param {object} [opts]
- * @param {string} [opts.caption]
- * @param {string} [opts.title]
- * @param {string} [opts.performer]
- */
-/**
- * Send any file as a Telegram document (PDF, zip, txt, etc).
- * @param {string} token
- * @param {string|number} chatId
- * @param {string|Buffer} document  Path or Buffer of document data
- * @param {object} [opts]
- * @param {string} [opts.caption]
- * @param {string} [opts.filename] override filename for Buffer input
- * @param {string} [opts.mime_type]
- */
-export async function sendDocument(token, chatId, document, { caption, filename, mime_type } = {}) {
-  const url = `${API_BASE}/bot${token}/sendDocument`;
-  const form = new FormData();
-  form.append("chat_id", String(chatId));
-  if (caption) form.append("caption", caption);
-
-  // URL string → let Telegram fetch it
-  if (typeof document === "string" && /^https?:\/\//.test(document)) {
-    form.append("document", document);
-  } else {
-    const buf = Buffer.isBuffer(document) ? document : fs.readFileSync(document);
-    const name =
-      filename ||
-      (typeof document === "string" ? path.basename(document) : "document.bin");
-    const blob = new Blob([buf], { type: mime_type || "application/octet-stream" });
-    form.append("document", blob, name);
-  }
-
-  const res = await fetch(url, { method: "POST", body: form });
-  const json = await res.json();
-  if (!json.ok) throw new Error(`sendDocument failed: ${json.description || res.status}`);
-  return json.result;
-}
-
-export async function sendAudio(token, chatId, audio, { caption, title, performer } = {}) {
-  const url = `${API_BASE}/bot${token}/sendAudio`;
-  const form = new FormData();
-  form.append("chat_id", String(chatId));
-  if (caption) form.append("caption", caption);
-  if (title) form.append("title", title);
-  if (performer) form.append("performer", performer);
-
-  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
-  const name = typeof audio === "string" ? path.basename(audio) : "audio.mp3";
-  const blob = new Blob([buf], { type: "audio/mpeg" });
-  form.append("audio", blob, name);
-
-  const res = await fetch(url, { method: "POST", body: form });
-  const json = await res.json();
-  if (!json.ok) throw new Error(`sendAudio failed: ${json.description || res.status}`);
-  return json.result;
-}
-
-// Audio transcription is delegated to the central dispatcher
-// (../transcription.js) which handles local (faster-whisper via Python) +
-// OpenAI cloud fallback. See that module for config keys.
-
-/**
- * Download a file from Telegram servers.
- * Returns the local file path where it was saved.
- */
-async function downloadTelegramFile(token, fileId, destDir) {
-  // Step 1: get file path from Telegram
-  const infoRes = await fetch(`${API_BASE}/bot${token}/getFile?file_id=${fileId}`);
-  const infoJson = await infoRes.json();
-  if (!infoJson.ok) throw new Error(`getFile failed: ${infoJson.description}`);
-  const filePath = infoJson.result.file_path; // e.g. "photos/file_123.jpg"
-  const ext = path.extname(filePath) || ".jpg";
-  const fileName = `tg_${fileId.slice(-8)}_${Date.now()}${ext}`;
-  const localPath = path.join(destDir, fileName);
-
-  // Step 2: download
-  const dlRes = await fetch(`${API_BASE}/file/bot${token}/${filePath}`);
-  if (!dlRes.ok) throw new Error(`download failed: ${dlRes.status}`);
-  const buf = Buffer.from(await dlRes.arrayBuffer());
-  fs.writeFileSync(localPath, buf);
-  return localPath;
-}
-
-// ---------- shared state ----------------------------------------------------
-
+// Media sending helpers moved to ./media.js.
+import { sendPhoto, sendVoice, sendDocument, sendAudio, downloadTelegramFile, API_BASE } from "./media.js";
+export { sendPhoto, sendVoice, sendDocument, sendAudio };
 function loadState() {
   if (!fs.existsSync(TELEGRAM_STATE_PATH)) return { channels: {} };
   try {
@@ -484,7 +338,7 @@ class ChannelPoller {
         const localPath = await downloadTelegramFile(token, bestPhoto.file_id, mediaDir);
         this.log(`telegram[${this.channel.name}] photo saved: ${localPath}`);
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "in",
           type: "photo",
           actor_id: msg.from?.id ? String(msg.from.id) : author,
@@ -550,7 +404,7 @@ class ChannelPoller {
         : `[audio] (transcription unavailable${transcribeError ? ": " + transcribeError : ""})`;
 
       appendGlobalMessage({
-        channel: "telegram",
+        channel: CHANNELS.TELEGRAM,
         direction: "in",
         type: "audio",
         actor_id: msg.from?.id ? String(msg.from.id) : author,
@@ -577,6 +431,30 @@ class ChannelPoller {
       text = text ? `${audioBody}\n${text}` : audioBody;
     }
 
+    // If there's a pending ask_questions flow for this chat AND the current
+    // question is free-text, treat this message as the answer rather than a
+    // brand-new turn. Returns true when the message was consumed.
+    if (chat_id && text && await this._maybeConsumeAskTextAnswer({ chat_id, text })) {
+      // Still log the inbound so the chat history records what the user said.
+      appendGlobalMessage({
+        channel: CHANNELS.TELEGRAM,
+        direction: "in",
+        type: "user",
+        actor_id: msg.from?.id ? String(msg.from.id) : author,
+        external_id: String(u.update_id),
+        author,
+        body: text,
+        meta: {
+          chat_id,
+          user_id: msg.from?.id || null,
+          message_id: msg.message_id,
+          tg_channel: this.channel.name,
+          ask_answer: true,
+        },
+      });
+      return;
+    }
+
     // /reset or /new wipes the rolling context for this chat. We just
     // remember a marker timestamp; subsequent inbounds will only consider
     // history newer than this. Implemented by writing a synthetic message
@@ -598,7 +476,7 @@ class ChannelPoller {
       // the next turn reads a [RESUMEN COMPACTADO] instead of raw history. Never
       // awaited — adds zero latency to this reply, degrades gracefully.
       compactChannelIfNeeded({
-        channel: "telegram",
+        channel: CHANNELS.TELEGRAM,
         chat_id,
         config: this.globalConfig,
         log: this.log,
@@ -622,7 +500,7 @@ class ChannelPoller {
 
     // Always log inbound to global store (~/.apx/messages/telegram/)
     appendGlobalMessage({
-      channel: "telegram",
+      channel: CHANNELS.TELEGRAM,
       direction: "in",
       type: "user",
       actor_id: msg.from?.id ? String(msg.from.id) : author,
@@ -654,7 +532,7 @@ class ChannelPoller {
         const ack = "Done, context cleared. Starting fresh. What do you need?";
         await this._send({ chat_id, text: ack });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "agent",
           actor_id: SUPERAGENT_ACTOR_ID,
@@ -678,7 +556,7 @@ class ChannelPoller {
     let replyActorId;   // stable id: super_agent | agent slug
     let replyKind;      // actor_kind: superagent | agent
     const projectCfg = target.config || this.globalConfig;
-    // Display name for the super-agent persona on this channel (Roby / APX).
+    // Display name for the super-agent persona on this channel (from identity.json).
     const agentDisplay = resolveAgentName(this.globalConfig);
 
     // Try the project's chosen agent first (skipped if the legacy
@@ -752,7 +630,7 @@ class ChannelPoller {
             const heads = headsUpPhrase();
             await this._send({ chat_id, text: heads });
             appendGlobalMessage({
-              channel: "telegram",
+              channel: CHANNELS.TELEGRAM,
               direction: "out",
               type: "agent",
               actor_id: SUPERAGENT_ACTOR_ID,
@@ -767,11 +645,17 @@ class ChannelPoller {
           if (ev.type === "assistant_text" && ev.text) {
             const piece = stripThinking(ev.text).trim();
             if (!piece) return;
+            // Skip post-tool segments that just restate the pre-tool intro —
+            // weaker models (gemini-flash et al.) frequently paraphrase the
+            // same content twice within a single turn.
+            if (lastStreamedText && isLikelyDuplicate(piece, lastStreamedText)) {
+              return;
+            }
             await this._send({ chat_id, text: piece });
             lastStreamedText = piece;
             streamedCount += 1;
             appendGlobalMessage({
-              channel: "telegram",
+              channel: CHANNELS.TELEGRAM,
               direction: "out",
               type: "agent",
               actor_id: SUPERAGENT_ACTOR_ID,
@@ -791,7 +675,7 @@ class ChannelPoller {
             // Logged for the audit trail / other channels — NOT sent to Telegram.
             const t = ev.trace;
             appendGlobalMessage({
-              channel: "telegram",
+              channel: CHANNELS.TELEGRAM,
               direction: "out",
               type: "tool",
               actor_id: t.tool,
@@ -821,17 +705,24 @@ class ChannelPoller {
         pendingStore: getConfirmStore(),
       });
 
+      // `/slug ...` shortcut: load the matching skill body into contextNote
+      // and strip the prefix from the user prompt before sending to the loop.
+      const slashed = tryResolveSkillCommand(text, { projectPath: target?.path });
+      const slashedPrompt = slashed.handled ? slashed.prompt : text;
+      const slashedContextNote = slashed.handled ? slashed.contextNote : "";
+
       try {
         const sa = await runSuperAgent({
           globalConfig: this.globalConfig,
           projects: this.projects,
           plugins: this.plugins,
           registries: this.registries,
-          prompt: text,
+          prompt: slashedPrompt,
           previousMessages,
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           relationshipBlock,
           allowedTools,
+          contextNote: slashedContextNote || undefined,
           channelMeta: buildTelegramMeta({
             channelName: this.channel.name,
             author,
@@ -848,6 +739,35 @@ class ChannelPoller {
         replyActorId = SUPERAGENT_ACTOR_ID;
         replyKind = "superagent";
         saUsage = sa.usage;
+
+        // ── ask_questions integration ────────────────────────────────────
+        // If the super-agent ended this turn by calling ask_questions, hand
+        // off to the inline-keyboard flow instead of sending the bare
+        // assistant text. The flow keeps state per chat_id and re-runs the
+        // super-agent once every answer is collected.
+        const askQuestions = askFlow.extractAskQuestionsFromTrace(sa.trace);
+        if (askQuestions && chat_id) {
+          if (chat_id) this.activeRequests.delete(chat_id);
+          stopTyping();
+          try {
+            await this._startAskFlow({
+              chat_id,
+              projectId: target?.id,
+              authorId: msg.from?.id,
+              questions: askQuestions,
+              author,
+              agentDisplay,
+              relationshipBlock,
+              allowedTools,
+              target,
+              sender,
+              update_id: u.update_id,
+            });
+          } catch (e) {
+            this.log(`telegram[${this.channel.name}] ask flow start failed: ${e.message}`);
+          }
+          return; // The reply for this turn IS the ask flow.
+        }
       } catch (e) {
         if (abortCtrl.signal.aborted) {
           // A newer message superseded this one. Whatever streamed so far is
@@ -878,8 +798,13 @@ class ChannelPoller {
     // turn isn't silently empty.
     const finalClean = replyText ? stripThinking(replyText).trim() : "";
     let toSend = "";
-    if (finalClean && finalClean !== lastStreamedText) toSend = finalClean;
-    else if (!finalClean && streamedCount === 0) toSend = "Listo.";
+    // Fuzzy dedupe against the last streamed segment: catches paraphrases
+    // (Jaccard ≥ 0.4 or short-mostly-inside-long), not just exact matches.
+    if (finalClean && !isLikelyDuplicate(finalClean, lastStreamedText) && finalClean !== lastStreamedText) {
+      toSend = finalClean;
+    } else if (!finalClean && streamedCount === 0) {
+      toSend = "Listo.";
+    }
 
     stopTyping();
     if (!toSend) return; // everything was already streamed — nothing left to send
@@ -895,7 +820,7 @@ class ChannelPoller {
       if (replyText && stripThinking(replyText) !== replyText) meta.thinking_stripped = true;
       if (saUsage) meta.usage = saUsage;
       appendGlobalMessage({
-        channel: "telegram",
+        channel: CHANNELS.TELEGRAM,
         direction: "out",
         type: "agent",
         actor_id: replyActorId || SUPERAGENT_ACTOR_ID,
@@ -908,7 +833,7 @@ class ChannelPoller {
     } catch (e) {
       this.log(`telegram[${this.channel.name}] send-back error: ${e.message}`);
       appendGlobalMessage({
-        channel: "telegram",
+        channel: CHANNELS.TELEGRAM,
         direction: "out",
         type: "agent",
         actor_id: replyActorId || SUPERAGENT_ACTOR_ID,
@@ -928,6 +853,14 @@ class ChannelPoller {
   }
 
   async _handleCallbackQuery(callbackQuery) {
+    // Route ask_questions button presses before the confirmation adapter —
+    // both use `apx:<verb>:...` namespacing but ask owns its own state.
+    const data = callbackQuery.data || "";
+    if (data.startsWith("apx:ask:")) {
+      await this._handleAskCallback(callbackQuery);
+      return;
+    }
+
     const adapter = createTelegramConfirmAdapter({
       token: resolveBotToken(this.channel),
       chatId: callbackQuery.message?.chat?.id,
@@ -939,6 +872,230 @@ class ChannelPoller {
     }
   }
 
+  // ── ask_questions: state-machine helpers ───────────────────────────────
+  // The flow lives in telegram-ask.js; this class owns the I/O (sending
+  // messages, editing keyboards, re-entering the super-agent loop with the
+  // compiled answer once the flow finishes).
+
+  async _renderQuestion(state) {
+    const text = askFlow.formatQuestionText(state);
+    const reply_markup = askFlow.buildKeyboard(state);
+    // If we already have a message for the previous question, leave its
+    // keyboard wiped — we draw a fresh message per question for clearer
+    // history in the chat (the question text stays as a record).
+    if (state.messageId) {
+      try {
+        await this._editKeyboard({
+          chat_id: state.chatId,
+          message_id: state.messageId,
+          reply_markup: { inline_keyboard: [] },
+        });
+      } catch { /* best-effort */ }
+    }
+    const sent = await this._send({
+      chat_id: state.chatId,
+      text,
+      reply_markup,
+      parse_mode: "Markdown",
+    });
+    state.messageId = sent?.message_id || null;
+    askFlow.saveState(state.chatId, state);
+  }
+
+  // Kick off a brand-new ask flow after the super-agent called ask_questions.
+  // The flow's `resume` callback captures the per-turn context (sender,
+  // relationship, project) so when the compiled answer arrives we can run
+  // another super-agent turn without retyping all the inputs.
+  async _startAskFlow(ctx) {
+    const state = askFlow.startFlow({
+      chatId: ctx.chat_id,
+      projectId: ctx.projectId,
+      authorId: ctx.authorId,
+      questions: ctx.questions,
+      resume: async (compiled) => {
+        await this._runResumedTurn({ ...ctx, compiled });
+      },
+    });
+    await this._renderQuestion(state);
+  }
+
+  // Apply an inline-keyboard press, then react: redraw, advance, or finish.
+  async _handleAskCallback(callbackQuery) {
+    const chatId = callbackQuery.message?.chat?.id;
+    if (!chatId) return;
+    const result = askFlow.applyCallback(chatId, callbackQuery.data || "");
+    // Ack the press regardless — keeps the spinner from hanging client-side.
+    await this._answerCallback({ callback_query_id: callbackQuery.id });
+    if (!result) return; // stale or unknown — adapter already ack'd.
+
+    if (result.action === "redraw") {
+      // Multi-select toggle: just refresh the keyboard on the SAME message.
+      try {
+        await this._editKeyboard({
+          chat_id: chatId,
+          message_id: callbackQuery.message?.message_id,
+          reply_markup: askFlow.buildKeyboard(result.state),
+        });
+      } catch (e) {
+        this.log(`telegram[${this.channel.name}] redraw failed: ${e.message}`);
+      }
+      return;
+    }
+    if (result.action === "advance") {
+      await this._renderQuestion(result.state);
+      return;
+    }
+    if (result.action === "cancel") {
+      try {
+        await this._editKeyboard({
+          chat_id: chatId,
+          message_id: callbackQuery.message?.message_id,
+          reply_markup: { inline_keyboard: [] },
+        });
+        await this._send({ chat_id: chatId, text: "Pregunta cancelada." });
+      } catch { /* best-effort */ }
+      return;
+    }
+    if (result.action === "done") {
+      try {
+        await this._editKeyboard({
+          chat_id: chatId,
+          message_id: callbackQuery.message?.message_id,
+          reply_markup: { inline_keyboard: [] },
+        });
+      } catch { /* best-effort */ }
+      // Feed the compiled answer back as a synthetic user turn.
+      if (typeof result.state.resume === "function") {
+        await result.state.resume(result.compiled);
+      }
+    }
+  }
+
+  // Apply a free-text user reply when there's a pending free-text question.
+  // Returns true iff the message was consumed by the ask flow (so the normal
+  // super-agent path should be skipped for this update).
+  async _maybeConsumeAskTextAnswer({ chat_id, text }) {
+    if (!chat_id || !text) return false;
+    if (!askFlow.hasPendingFreeText(chat_id)) return false;
+    const state = askFlow.applyTextAnswer(chat_id, text);
+    if (!state) return false;
+    // Advance: emit a synthetic "next" to move past this question.
+    const next = askFlow.applyCallback(
+      chat_id,
+      `apx:ask:${state.correlationId}:next`,
+    );
+    if (!next) return true;
+    if (next.action === "advance") {
+      await this._renderQuestion(next.state);
+      return true;
+    }
+    if (next.action === "done") {
+      if (typeof next.state.resume === "function") {
+        await next.state.resume(next.compiled);
+      }
+      return true;
+    }
+    return true;
+  }
+
+  // Run a follow-up super-agent turn with the compiled answers as the user
+  // prompt. Mirrors the post-runSuperAgent reply path in _handleUpdate but
+  // skipped of the photo/audio/reset preamble. Re-enters the ask flow if the
+  // model decides to ask again.
+  async _runResumedTurn(ctx) {
+    const { chat_id, compiled, target, relationshipBlock, allowedTools, author, agentDisplay, update_id, sender, authorId } = ctx;
+    if (!chat_id) return;
+    // Log the synthetic user message so getRecentTelegramTurnsFromFs picks
+    // it up on the NEXT inbound. Mirrors how a normal text reply would be
+    // recorded.
+    appendGlobalMessage({
+      channel: CHANNELS.TELEGRAM,
+      direction: "in",
+      type: "user",
+      actor_id: authorId ? String(authorId) : (author || "ask_flow"),
+      external_id: `ask-${Date.now()}`,
+      author: author || "user",
+      body: compiled,
+      meta: {
+        chat_id,
+        user_id: authorId || null,
+        tg_channel: this.channel.name,
+        ask_flow: true,
+      },
+    });
+
+    const previousMessages = getRecentTelegramTurnsFromFs({
+      chat_id,
+      keepRecent: 40,
+      max_age_hours: 24,
+    });
+
+    const stopTyping = this._startTyping(chat_id);
+    try {
+      const sa = await runSuperAgent({
+        globalConfig: this.globalConfig,
+        projects: this.projects,
+        plugins: this.plugins,
+        registries: this.registries,
+        prompt: compiled,
+        previousMessages,
+        channel: CHANNELS.TELEGRAM,
+        relationshipBlock,
+        allowedTools,
+        channelMeta: { channel: CHANNELS.TELEGRAM, chat_id, author, route_to_agent: this.channel.route_to_agent },
+      });
+      stopTyping();
+
+      // Did the model ask again? Restart the flow instead of replying.
+      const followupAsk = askFlow.extractAskQuestionsFromTrace(sa.trace);
+      if (followupAsk) {
+        await this._startAskFlow({
+          chat_id,
+          projectId: target?.id,
+          authorId,
+          questions: followupAsk,
+          author,
+          agentDisplay,
+          relationshipBlock,
+          allowedTools,
+          target,
+          sender,
+          update_id,
+        });
+        return;
+      }
+
+      const replyText = sa.text ? stripThinking(sa.text).trim() : "";
+      if (replyText) {
+        await this._send({ chat_id, text: replyText });
+        appendGlobalMessage({
+          channel: CHANNELS.TELEGRAM,
+          direction: "out",
+          type: "agent",
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          agent_slug: SUPERAGENT_ACTOR_ID,
+          author: sa.name || agentDisplay,
+          body: replyText,
+          meta: {
+            chat_id,
+            tg_channel: this.channel.name,
+            in_reply_to: update_id,
+            final: true,
+            ask_resume: true,
+            ...(sa.usage ? { usage: sa.usage } : {}),
+          },
+        });
+      }
+    } catch (e) {
+      stopTyping();
+      this.log(`telegram[${this.channel.name}] ask resume failed: ${e.message}`);
+      try {
+        await this._send({ chat_id, text: `⚠️ Error procesando tus respuestas (${e.message}).` });
+      } catch { /* best-effort */ }
+    }
+  }
+
   // Show "typing..." indicator in the chat. Telegram clears it automatically
   // after 5 seconds, so call this every ~4s while a long operation is going.
   async _typing(chat_id) {
@@ -971,22 +1128,64 @@ class ChannelPoller {
     return () => { stopped = true; };
   }
 
-  async _send({ chat_id, text }) {
+  async _send({ chat_id, text, reply_markup, parse_mode }) {
     const token = resolveBotToken(this.channel);
     if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
     const target = chat_id || resolveChatId(this.channel);
     if (!target) throw new Error(`channel ${this.channel.name}: no chat_id`);
     const url = `${API_BASE}/bot${token}/sendMessage`;
+    const body = { chat_id: target, text };
+    if (reply_markup) body.reply_markup = reply_markup;
+    if (parse_mode) body.parse_mode = parse_mode;
     const res = await fetch(url, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ chat_id: target, text }),
+      body: JSON.stringify(body),
     });
     const json = await res.json();
     if (!json.ok) throw new Error(json.description || `send failed (${res.status})`);
     return json.result;
   }
 
+  // Replace just the inline keyboard on a previously-sent message (used to
+  // refresh after a multi-select toggle, or to wipe buttons once the flow
+  // has moved on). Best-effort: failures are logged but don't break the flow.
+  async _editKeyboard({ chat_id, message_id, reply_markup }) {
+    const token = resolveBotToken(this.channel);
+    if (!token) return;
+    try {
+      const url = `${API_BASE}/bot${token}/editMessageReplyMarkup`;
+      const body = { chat_id, message_id };
+      if (reply_markup) body.reply_markup = reply_markup;
+      await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+      });
+    } catch (e) {
+      this.log(`telegram[${this.channel.name}] editMessageReplyMarkup failed: ${e.message}`);
+    }
+  }
+
+  // Acknowledge a callback button press so the user's Telegram client clears
+  // the spinner on the tapped button. Optional `text` shows a small toast.
+  async _answerCallback({ callback_query_id, text }) {
+    const token = resolveBotToken(this.channel);
+    if (!token) return;
+    try {
+      const url = `${API_BASE}/bot${token}/answerCallbackQuery`;
+      const body = { callback_query_id };
+      if (text) body.text = text;
+      await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+      });
+    } catch (e) {
+      this.log(`telegram[${this.channel.name}] answerCallbackQuery failed: ${e.message}`);
+    }
+  }
+
   /** Send a photo via this channel */
   async _sendPhoto({ chat_id, photo, caption, parse_mode }) {
     const token = resolveBotToken(this.channel);
@@ -1073,7 +1272,7 @@ export default {
         if (!p) throw new Error("no telegram channel available");
         const result = await p._send({ chat_id, text });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "agent",
           actor_id: SUPERAGENT_ACTOR_ID,
@@ -1103,7 +1302,7 @@ export default {
         if (!p) throw new Error("no telegram channel available");
         const result = await p._sendPhoto({ chat_id, photo, caption, parse_mode });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "photo",
           actor_id: SUPERAGENT_ACTOR_ID,
@@ -1127,7 +1326,7 @@ export default {
         if (!p) throw new Error("no telegram channel available");
         const result = await p._sendVoice({ chat_id, audio, caption, duration });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "voice",
           actor_id: SUPERAGENT_ACTOR_ID,
@@ -1151,7 +1350,7 @@ export default {
         if (!p) throw new Error("no telegram channel available");
         const result = await p._sendDocument({ chat_id, document, caption, filename, mime_type });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "document",
           actor_id: SUPERAGENT_ACTOR_ID,
@@ -1175,7 +1374,7 @@ export default {
         if (!p) throw new Error("no telegram channel available");
         const result = await p._sendAudio({ chat_id, audio, caption, title, performer });
         appendGlobalMessage({
-          channel: "telegram",
+          channel: CHANNELS.TELEGRAM,
           direction: "out",
           type: "audio",
           actor_id: SUPERAGENT_ACTOR_ID,