gsd-pi 2.19.0 → 2.20.0

package/src/resources/extensions/remote-questions/format.ts

@@ -18,7 +18,8 @@ export interface DiscordEmbed {
   footer?: { text: string };
 }
 
-const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+export const DISCORD_NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+export const SLACK_NUMBER_REACTION_NAMES = ["one", "two", "three", "four", "five"];
 const MAX_USER_NOTE_LENGTH = 500;
 
 export function formatForSlack(prompt: RemotePrompt): SlackBlock[] {
@@ -29,7 +30,18 @@ export function formatForSlack(prompt: RemotePrompt): SlackBlock[] {
     },
   ];
 
+  if (prompt.questions.length > 1) {
+    blocks.push({
+      type: "context",
+      elements: [{
+        type: "mrkdwn",
+        text: "Reply once in thread using one line per question or semicolons (`1; 2; custom note`).",
+      }],
+    });
+  }
+
   for (const q of prompt.questions) {
+    const supportsReactions = prompt.questions.length === 1;
     blocks.push({
       type: "section",
       text: { type: "mrkdwn", text: `*${q.header}*\n${q.question}` },
@@ -47,15 +59,33 @@ export function formatForSlack(prompt: RemotePrompt): SlackBlock[] {
       type: "context",
       elements: [{
         type: "mrkdwn",
-        text: q.allowMultiple
-          ? "Reply in thread with comma-separated numbers (`1,3`) or free text."
-          : "Reply in thread with a number (`1`) or free text.",
+        text: prompt.questions.length > 1
+          ? (q.allowMultiple
+              ? "For this question, use comma-separated numbers (`1,3`) or free text."
+              : "For this question, use one number (`1`) or free text.")
+          : (q.allowMultiple
+              ? (supportsReactions
+                  ? "Reply in thread with comma-separated numbers (`1,3`) or react with matching number emoji."
+                  : "Reply in thread with comma-separated numbers (`1,3`) or free text.")
+              : (supportsReactions
+                  ? "Reply in thread with a number (`1`) or react with the matching number emoji."
+                  : "Reply in thread with a number (`1`) or free text.")),
       }],
     });
 
     blocks.push({ type: "divider" });
   }
 
+  if (prompt.context?.source) {
+    blocks.push({
+      type: "context",
+      elements: [{
+        type: "mrkdwn",
+        text: `Source: \`${prompt.context.source}\``,
+      }],
+    });
+  }
+
   return blocks;
 }
 
@@ -64,8 +94,8 @@ export function formatForDiscord(prompt: RemotePrompt): { embeds: DiscordEmbed[]
   const embeds: DiscordEmbed[] = prompt.questions.map((q, questionIndex) => {
     const supportsReactions = prompt.questions.length === 1;
     const optionLines = q.options.map((opt, i) => {
-      const emoji = NUMBER_EMOJIS[i] ?? `${i + 1}.`;
-      if (supportsReactions && NUMBER_EMOJIS[i]) reactionEmojis.push(NUMBER_EMOJIS[i]);
+      const emoji = DISCORD_NUMBER_EMOJIS[i] ?? `${i + 1}.`;
+      if (supportsReactions && DISCORD_NUMBER_EMOJIS[i]) reactionEmojis.push(DISCORD_NUMBER_EMOJIS[i]);
       return `${emoji} **${opt.label}** — ${opt.description}`;
     });
 
@@ -130,8 +160,33 @@ export function parseDiscordResponse(
 
   const q = questions[0];
   const picked = reactions
-    .filter((r) => NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
-    .map((r) => q.options[NUMBER_EMOJIS.indexOf(r.emoji)]?.label)
+    .filter((r) => DISCORD_NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
+    .map((r) => q.options[DISCORD_NUMBER_EMOJIS.indexOf(r.emoji)]?.label)
+    .filter(Boolean) as string[];
+
+  answers[q.id] = picked.length > 0
+    ? { answers: q.allowMultiple ? picked : [picked[0]] }
+    : { answers: [], user_note: "No clear response via reactions" };
+
+  return { answers };
+}
+
+export function parseSlackReactionResponse(
+  reactionNames: string[],
+  questions: RemoteQuestion[],
+): RemoteAnswer {
+  const answers: RemoteAnswer["answers"] = {};
+  if (questions.length !== 1) {
+    for (const q of questions) {
+      answers[q.id] = { answers: [], user_note: "Slack reactions are only supported for single-question prompts" };
+    }
+    return { answers };
+  }
+
+  const q = questions[0];
+  const picked = reactionNames
+    .filter((name) => SLACK_NUMBER_REACTION_NAMES.includes(name))
+    .map((name) => q.options[SLACK_NUMBER_REACTION_NAMES.indexOf(name)]?.label)
     .filter(Boolean) as string[];
 
   answers[q.id] = picked.length > 0
@@ -141,6 +196,97 @@ export function parseDiscordResponse(
   return { answers };
 }
 
+export interface TelegramInlineButton {
+  text: string;
+  callback_data: string;
+}
+
+export interface TelegramInlineKeyboardMarkup {
+  inline_keyboard: TelegramInlineButton[][];
+}
+
+export interface TelegramMessage {
+  text: string;
+  parse_mode: "HTML";
+  reply_markup?: TelegramInlineKeyboardMarkup;
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export function formatForTelegram(prompt: RemotePrompt): TelegramMessage {
+  const lines: string[] = ["<b>GSD needs your input</b>", ""];
+
+  for (let qi = 0; qi < prompt.questions.length; qi++) {
+    const q = prompt.questions[qi];
+    lines.push(`<b>${escapeHtml(q.header)}</b>`);
+    lines.push(escapeHtml(q.question));
+    lines.push("");
+
+    for (let i = 0; i < q.options.length; i++) {
+      lines.push(`${i + 1}. <b>${escapeHtml(q.options[i].label)}</b> — ${escapeHtml(q.options[i].description)}`);
+    }
+
+    lines.push("");
+    if (prompt.questions.length === 1) {
+      lines.push(q.allowMultiple
+        ? "Reply with comma-separated numbers (1,3) or free text."
+        : "Reply with a number or tap a button below.");
+    } else {
+      lines.push(`Question ${qi + 1}/${prompt.questions.length} — reply with one line per question or use semicolons.`);
+    }
+
+    if (qi < prompt.questions.length - 1) lines.push("");
+  }
+
+  const result: TelegramMessage = {
+    text: lines.join("\n"),
+    parse_mode: "HTML",
+  };
+
+  // Inline keyboard for single-question with <=5 options
+  const isSingle = prompt.questions.length === 1;
+  if (isSingle && prompt.questions[0].options.length <= 5) {
+    result.reply_markup = {
+      inline_keyboard: prompt.questions[0].options.map((opt, i) => [{
+        text: `${i + 1}. ${opt.label}`,
+        callback_data: `${prompt.id}:${i}`,
+      }]),
+    };
+  }
+
+  return result;
+}
+
+export function parseTelegramResponse(
+  callbackData: string | null,
+  replyText: string | null,
+  questions: RemoteQuestion[],
+  promptId: string,
+): RemoteAnswer {
+  // Handle callback_data from inline keyboard button press
+  if (callbackData) {
+    const match = callbackData.match(new RegExp(`^${promptId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:(\\d+)$`));
+    if (match && questions.length === 1) {
+      const idx = parseInt(match[1], 10);
+      const q = questions[0];
+      if (idx >= 0 && idx < q.options.length) {
+        return { answers: { [q.id]: { answers: [q.options[idx].label] } } };
+      }
+    }
+  }
+
+  // Handle text reply — delegate to parseSlackReply (text parsing is format-agnostic)
+  if (replyText) return parseSlackReply(replyText, questions);
+
+  const answers: RemoteAnswer["answers"] = {};
+  for (const q of questions) {
+    answers[q.id] = { answers: [], user_note: "No response provided" };
+  }
+  return { answers };
+}
+
 function parseAnswerForQuestion(text: string, q: RemoteQuestion): { answers: string[]; user_note?: string } {
   if (!text) return { answers: [], user_note: "No response provided" };
 

package/src/resources/extensions/remote-questions/manager.ts

@@ -5,8 +5,9 @@
 import { randomUUID } from "node:crypto";
 import type { ChannelAdapter, RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
 import { resolveRemoteConfig, type ResolvedConfig } from "./config.js";
-import { SlackAdapter } from "./slack-adapter.js";
 import { DiscordAdapter } from "./discord-adapter.js";
+import { SlackAdapter } from "./slack-adapter.js";
+import { TelegramAdapter } from "./telegram-adapter.js";
 import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
 
 interface ToolResult {
@@ -77,10 +78,10 @@ export async function tryRemoteQuestions(
 
   markPromptAnswered(prompt.id, answer);
 
-  // Acknowledge receipt with a ✅ on Discord (Slack threads are self-evident)
-  if (config.channel === "discord" && dispatch.ref) {
+  // Best-effort acknowledgement gives remote users a visible receipt signal.
+  if (dispatch.ref) {
     try {
-      await (adapter as import("./discord-adapter.js").DiscordAdapter).acknowledgeAnswer(dispatch.ref);
+      await adapter.acknowledgeAnswer?.(dispatch.ref);
     } catch { /* best-effort */ }
   }
 
@@ -119,9 +120,9 @@ function createPrompt(questions: QuestionInput[], config: ResolvedConfig): Remot
 }
 
 function createAdapter(config: ResolvedConfig): ChannelAdapter {
-  return config.channel === "slack"
-    ? new SlackAdapter(config.token, config.channelId)
-    : new DiscordAdapter(config.token, config.channelId);
+  if (config.channel === "slack") return new SlackAdapter(config.token, config.channelId);
+  if (config.channel === "telegram") return new TelegramAdapter(config.token, config.channelId);
+  return new DiscordAdapter(config.token, config.channelId);
 }
 
 async function pollUntilDone(
@@ -181,6 +182,7 @@ const TOKEN_PATTERNS = [
   /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
   /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
   /xoxa-[A-Za-z0-9\-]+/g,    // Slack app tokens
+  /\d{8,10}:[A-Za-z0-9_-]{35}/g, // Telegram bot tokens
   /[A-Za-z0-9_\-.]{20,}/g,   // Long opaque secrets (Discord tokens, etc.)
 ];
 

package/src/resources/extensions/remote-questions/remote-command.ts

@@ -21,6 +21,7 @@ export async function handleRemote(
 
   if (trimmed === "slack") return handleSetupSlack(ctx);
   if (trimmed === "discord") return handleSetupDiscord(ctx);
+  if (trimmed === "telegram") return handleSetupTelegram(ctx);
   if (trimmed === "status") return handleRemoteStatus(ctx);
   if (trimmed === "disconnect") return handleDisconnect(ctx);
 
@@ -36,9 +37,28 @@ async function handleSetupSlack(ctx: ExtensionCommandContext): Promise<void> {
   const auth = await fetchJson("https://slack.com/api/auth.test", { headers: { Authorization: `Bearer ${token}` } });
   if (!auth?.ok) return void ctx.ui.notify("Token validation failed — check the token and app install.", "error");
 
-  const channelId = await promptInput(ctx, "Channel ID", "Paste the Slack channel ID (e.g. C0123456789)");
+  const channels = await listSlackChannels(token);
+  const MANUAL_OPTION = "Enter channel ID manually";
+  let channelId: string;
+
+  if (!channels || channels.length === 0) {
+    ctx.ui.notify("Could not list Slack channels — falling back to manual entry.", "warning");
+    channelId = await promptSlackChannelId(ctx) ?? "";
+  } else {
+    const channelOptions = [...channels.map((channel) => channel.label), MANUAL_OPTION];
+    const selectedChannel = await ctx.ui.select("Select a Slack channel", channelOptions);
+    if (!selectedChannel) return void ctx.ui.notify("Slack setup cancelled.", "info");
+
+    if (selectedChannel === MANUAL_OPTION) {
+      channelId = await promptSlackChannelId(ctx) ?? "";
+    } else {
+      const chosen = channels.find((channel) => channel.label === selectedChannel);
+      if (!chosen) return void ctx.ui.notify("Slack setup cancelled.", "info");
+      channelId = chosen.id;
+    }
+  }
+
   if (!channelId) return void ctx.ui.notify("Slack setup cancelled.", "info");
-  if (!isValidChannelId("slack", channelId)) return void ctx.ui.notify("Invalid Slack channel ID format — expected 9-12 uppercase alphanumeric characters.", "error");
 
   const send = await fetchJson("https://slack.com/api/chat.postMessage", {
     method: "POST",
@@ -136,6 +156,32 @@ async function handleSetupDiscord(ctx: ExtensionCommandContext): Promise<void> {
   ctx.ui.notify(`Discord connected — remote questions enabled for channel ${channelId}.`, "info");
 }
 
+async function handleSetupTelegram(ctx: ExtensionCommandContext): Promise<void> {
+  const token = await promptMaskedInput(ctx, "Telegram Bot Token", "Paste your bot token from @BotFather");
+  if (!token) return void ctx.ui.notify("Telegram setup cancelled.", "info");
+  if (!/^\d+:[A-Za-z0-9_-]+$/.test(token)) return void ctx.ui.notify("Invalid token format — Telegram bot tokens look like 123456789:ABCdefGHI...", "warning");
+
+  ctx.ui.notify("Validating token...", "info");
+  const auth = await fetchJson(`https://api.telegram.org/bot${token}/getMe`);
+  if (!auth?.ok || !auth?.result?.id) return void ctx.ui.notify("Token validation failed — check the bot token.", "error");
+
+  const chatId = await promptInput(ctx, "Chat ID", "Paste the Telegram chat ID (e.g. -1001234567890)");
+  if (!chatId) return void ctx.ui.notify("Telegram setup cancelled.", "info");
+  if (!isValidChannelId("telegram", chatId)) return void ctx.ui.notify("Invalid Telegram chat ID format — expected a numeric ID (can be negative for groups).", "error");
+
+  const send = await fetchJson(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text: "GSD remote questions connected." }),
+  });
+  if (!send?.ok) return void ctx.ui.notify(`Could not send to chat: ${send?.description ?? "unknown error"}`, "error");
+
+  saveProviderToken("telegram_bot", token);
+  process.env.TELEGRAM_BOT_TOKEN = token;
+  saveRemoteQuestionsConfig("telegram", chatId);
+  ctx.ui.notify(`Telegram connected — remote questions enabled for chat ${chatId}.`, "info");
+}
+
 async function handleRemoteStatus(ctx: ExtensionCommandContext): Promise<void> {
   const status = getRemoteConfigStatus();
   const config = resolveRemoteConfig();
@@ -161,9 +207,11 @@ async function handleDisconnect(ctx: ExtensionCommandContext): Promise<void> {
   if (!channel) return void ctx.ui.notify("No remote channel configured — nothing to disconnect.", "info");
 
   removeRemoteQuestionsConfig();
-  removeProviderToken(channel === "slack" ? "slack_bot" : "discord_bot");
+  const providerMap: Record<string, string> = { slack: "slack_bot", discord: "discord_bot", telegram: "telegram_bot" };
+  removeProviderToken(providerMap[channel] ?? channel);
   if (channel === "slack") delete process.env.SLACK_BOT_TOKEN;
   if (channel === "discord") delete process.env.DISCORD_BOT_TOKEN;
+  if (channel === "telegram") delete process.env.TELEGRAM_BOT_TOKEN;
   ctx.ui.notify(`Remote questions disconnected (${channel}).`, "info");
 }
 
@@ -181,6 +229,7 @@ async function handleRemoteMenu(ctx: ExtensionCommandContext): Promise<void> {
         "  /gsd remote disconnect",
         "  /gsd remote slack",
         "  /gsd remote discord",
+        "  /gsd remote telegram",
       ]
     : [
         "No remote question channel configured.",
@@ -188,6 +237,7 @@ async function handleRemoteMenu(ctx: ExtensionCommandContext): Promise<void> {
         "Commands:",
         "  /gsd remote slack",
         "  /gsd remote discord",
+        "  /gsd remote telegram",
         "  /gsd remote status",
       ];
 
@@ -203,6 +253,52 @@ async function fetchJson(url: string, init?: RequestInit): Promise<any> {
   }
 }
 
+async function listSlackChannels(token: string): Promise<Array<{ id: string; label: string }> | null> {
+  const headers = { Authorization: `Bearer ${token}` };
+  const channels: Array<{ id: string; label: string; name: string }> = [];
+  let cursor = "";
+
+  do {
+    const params = new URLSearchParams({
+      exclude_archived: "true",
+      limit: "200",
+      types: "public_channel,private_channel",
+    });
+    if (cursor) params.set("cursor", cursor);
+
+    const response = await fetchJson(`https://slack.com/api/users.conversations?${params.toString()}`, { headers });
+    if (!response?.ok || !Array.isArray(response.channels)) {
+      return channels.length > 0 ? channels.map(({ id, label }) => ({ id, label })) : null;
+    }
+
+    for (const channel of response.channels as Array<{ id?: string; name?: string; is_private?: boolean }>) {
+      if (!channel.id || !channel.name) continue;
+      channels.push({
+        id: channel.id,
+        name: channel.name,
+        label: channel.is_private ? `[private] ${channel.name}` : `#${channel.name}`,
+      });
+    }
+
+    cursor = typeof response.response_metadata?.next_cursor === "string"
+      ? response.response_metadata.next_cursor
+      : "";
+  } while (cursor);
+
+  channels.sort((a, b) => a.name.localeCompare(b.name));
+  return channels.map(({ id, label }) => ({ id, label }));
+}
+
+async function promptSlackChannelId(ctx: ExtensionCommandContext): Promise<string | null> {
+  const channelId = await promptInput(ctx, "Channel ID", "Paste the Slack channel ID (e.g. C0123456789)");
+  if (!channelId) return null;
+  if (!isValidChannelId("slack", channelId)) {
+    ctx.ui.notify("Invalid Slack channel ID format — expected 9-12 uppercase alphanumeric characters.", "error");
+    return null;
+  }
+  return channelId;
+}
+
 function getAuthStorage(): AuthStorage {
   const authPath = join(process.env.HOME ?? "", ".gsd", "agent", "auth.json");
   mkdirSync(dirname(authPath), { recursive: true });
@@ -219,7 +315,7 @@ function removeProviderToken(provider: string): void {
   auth.set(provider, { type: "api_key", key: "" });
 }
 
-export function saveRemoteQuestionsConfig(channel: "slack" | "discord", channelId: string): void {
+export function saveRemoteQuestionsConfig(channel: "slack" | "discord" | "telegram", channelId: string): void {
   const prefsPath = getGlobalGSDPreferencesPath();
   const block = [
     "remote_questions:",

package/src/resources/extensions/remote-questions/slack-adapter.ts

@@ -3,10 +3,11 @@
  */
 
 import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
-import { formatForSlack, parseSlackReply } from "./format.js";
+import { formatForSlack, parseSlackReply, parseSlackReactionResponse, SLACK_NUMBER_REACTION_NAMES } from "./format.js";
 
 const SLACK_API = "https://slack.com/api";
 const PER_REQUEST_TIMEOUT_MS = 15_000;
+const SLACK_ACK_REACTION = "white_check_mark";
 
 export class SlackAdapter implements ChannelAdapter {
   readonly name = "slack" as const;
@@ -36,6 +37,17 @@ export class SlackAdapter implements ChannelAdapter {
 
     const ts = String(res.ts);
     const channel = String(res.channel);
+    if (prompt.questions.length === 1) {
+      const reactionNames = SLACK_NUMBER_REACTION_NAMES.slice(0, prompt.questions[0].options.length);
+      for (const name of reactionNames) {
+        try {
+          await this.slackApi("reactions.add", { channel, timestamp: ts, name });
+        } catch {
+          // Best-effort only
+        }
+      }
+    }
+
     return {
       ref: {
         id: prompt.id,
@@ -51,6 +63,11 @@ export class SlackAdapter implements ChannelAdapter {
   async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
     if (!this.botUserId) await this.validate();
 
+    if (prompt.questions.length === 1) {
+      const reactionAnswer = await this.checkReactions(prompt, ref);
+      if (reactionAnswer) return reactionAnswer;
+    }
+
     const res = await this.slackApi("conversations.replies", {
       channel: ref.channelId,
       ts: ref.threadTs!,
@@ -66,9 +83,48 @@ export class SlackAdapter implements ChannelAdapter {
     return parseSlackReply(String(userReplies[0].text), prompt.questions);
   }
 
+  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
+    try {
+      await this.slackApi("reactions.add", {
+        channel: ref.channelId,
+        timestamp: ref.messageId,
+        name: SLACK_ACK_REACTION,
+      });
+    } catch {
+      // Best-effort only
+    }
+  }
+
+  private async checkReactions(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    const res = await this.slackApi("reactions.get", {
+      channel: ref.channelId,
+      timestamp: ref.messageId,
+      full: "true",
+    });
+
+    if (!res.ok) return null;
+
+    const message = (res.message ?? {}) as {
+      reactions?: Array<{ name?: string; count?: number; users?: string[] }>;
+    };
+    const reactions = Array.isArray(message.reactions) ? message.reactions : [];
+    const picked = reactions
+      .filter((reaction) => reaction.name && SLACK_NUMBER_REACTION_NAMES.includes(reaction.name))
+      .filter((reaction) => {
+        const count = Number(reaction.count ?? 0);
+        const users = Array.isArray(reaction.users) ? reaction.users.map(String) : [];
+        const botIncluded = this.botUserId ? users.includes(this.botUserId) : false;
+        return count > (botIncluded ? 1 : 0);
+      })
+      .map((reaction) => String(reaction.name));
+
+    if (picked.length === 0) return null;
+    return parseSlackReactionResponse(picked, prompt.questions);
+  }
+
   private async slackApi(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>> {
     const url = `${SLACK_API}/${method}`;
-    const isGet = method === "conversations.replies" || method === "auth.test";
+    const isGet = method === "conversations.replies" || method === "auth.test" || method === "reactions.get";
 
     let response: Response;
     if (isGet) {

package/src/resources/extensions/remote-questions/telegram-adapter.ts

@@ -0,0 +1,161 @@
+/**
+ * Remote Questions — Telegram adapter
+ */
+
+import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { formatForTelegram, parseTelegramResponse } from "./format.js";
+
+const TELEGRAM_API = "https://api.telegram.org";
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+
+export class TelegramAdapter implements ChannelAdapter {
+  readonly name = "telegram" as const;
+  private botUserId: number | null = null;
+  private lastUpdateId = 0;
+  private lastSentText = "";
+  private readonly token: string;
+  private readonly chatId: string;
+
+  constructor(token: string, chatId: string) {
+    this.token = token;
+    this.chatId = chatId;
+  }
+
+  async validate(): Promise<void> {
+    const res = await this.telegramApi("getMe");
+    if (!res.ok || !res.result?.id) throw new Error("Telegram auth failed: invalid bot token");
+    this.botUserId = res.result.id;
+  }
+
+  async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
+    const payload = formatForTelegram(prompt);
+    this.lastSentText = payload.text;
+
+    const params: Record<string, unknown> = {
+      chat_id: this.chatId,
+      text: payload.text,
+      parse_mode: payload.parse_mode,
+    };
+    if (payload.reply_markup) {
+      params.reply_markup = payload.reply_markup;
+    }
+
+    const res = await this.telegramApi("sendMessage", params);
+    if (!res.ok || !res.result?.message_id) {
+      throw new Error(`Telegram sendMessage failed: ${JSON.stringify(res)}`);
+    }
+
+    const messageId = String(res.result.message_id);
+    const messageUrl = this.buildMessageUrl(this.chatId, messageId);
+
+    return {
+      ref: {
+        id: prompt.id,
+        channel: "telegram",
+        messageId,
+        channelId: this.chatId,
+        threadUrl: messageUrl,
+      },
+    };
+  }
+
+  async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    if (!this.botUserId) await this.validate();
+
+    const res = await this.telegramApi("getUpdates", {
+      offset: this.lastUpdateId + 1,
+      timeout: 0,
+      allowed_updates: ["message", "callback_query"],
+    });
+
+    if (!res.ok || !Array.isArray(res.result)) return null;
+
+    for (const update of res.result) {
+      // Advance offset for all updates to prevent reprocessing
+      if (update.update_id > this.lastUpdateId) {
+        this.lastUpdateId = update.update_id;
+      }
+
+      // Handle callback_query (inline keyboard button press)
+      if (update.callback_query) {
+        const cq = update.callback_query;
+        const msg = cq.message;
+        if (
+          msg &&
+          String(msg.chat?.id) === ref.channelId &&
+          String(msg.message_id) === ref.messageId &&
+          cq.from?.id !== this.botUserId
+        ) {
+          // Dismiss the loading spinner on the button
+          try {
+            await this.telegramApi("answerCallbackQuery", { callback_query_id: cq.id });
+          } catch { /* best-effort */ }
+
+          return parseTelegramResponse(cq.data ?? null, null, prompt.questions, prompt.id);
+        }
+      }
+
+      // Handle text reply (reply_to_message)
+      if (update.message) {
+        const msg = update.message;
+        if (
+          String(msg.chat?.id) === ref.channelId &&
+          msg.reply_to_message &&
+          String(msg.reply_to_message.message_id) === ref.messageId &&
+          msg.from?.id !== this.botUserId &&
+          msg.text
+        ) {
+          return parseTelegramResponse(null, msg.text, prompt.questions, prompt.id);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Acknowledge receipt by editing the original message to append a checkmark.
+   * Best-effort — failures are silently ignored.
+   */
+  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
+    try {
+      await this.telegramApi("editMessageText", {
+        chat_id: ref.channelId,
+        message_id: parseInt(ref.messageId, 10),
+        text: this.lastSentText + "\n\n✅ Answered",
+        parse_mode: "HTML",
+      });
+    } catch {
+      // Best-effort — don't let acknowledgement failures affect the flow
+    }
+  }
+
+  private buildMessageUrl(chatId: string, messageId: string): string | undefined {
+    // Supergroups have chat IDs starting with -100
+    if (chatId.startsWith("-100")) {
+      return `https://t.me/c/${chatId.slice(4)}/${messageId}`;
+    }
+    return undefined;
+  }
+
+  private async telegramApi(method: string, params?: Record<string, unknown>): Promise<any> {
+    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
+    const init: RequestInit = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    };
+
+    if (params) {
+      init.body = JSON.stringify(params);
+    }
+
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
+      throw new Error(`Telegram API HTTP ${response.status}: ${safeText}`);
+    }
+    return response.json();
+  }
+}

package/src/resources/extensions/remote-questions/types.ts

@@ -2,7 +2,7 @@
  * Remote Questions — shared types
  */
 
-export type RemoteChannel = "slack" | "discord";
+export type RemoteChannel = "slack" | "discord" | "telegram";
 
 export interface RemoteQuestionOption {
   label: string;
@@ -72,4 +72,5 @@ export interface ChannelAdapter {
   validate(): Promise<void>;
   sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult>;
   pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null>;
+  acknowledgeAnswer?(ref: RemotePromptRef): Promise<void>;
 }