gsd-pi 2.18.0 → 2.20.0

package/src/resources/extensions/gsd/worktree-command.ts

@@ -13,6 +13,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch } from "./worktree.js";
+import { runWorktreePostCreateHook } from "./auto-worktree.js";
 import { showConfirm } from "../shared/confirm-ui.js";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import {
@@ -360,6 +361,12 @@ async function handleCreate(
     const mainBase = originalCwd ?? basePath;
     const info = createWorktree(mainBase, name);
 
+    // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
+    const hookError = runWorktreePostCreateHook(mainBase, info.path);
+    if (hookError) {
+      ctx.ui.notify(hookError, "warning");
+    }
+
     // Track original cwd before switching
     if (!originalCwd) originalCwd = basePath;
 
@@ -672,6 +679,17 @@ async function handleMerge(
     // Try a direct squash-merge first. Only fall back to LLM on conflict.
     const commitType = inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
+
+    // Reconcile worktree DB into main DB before squash merge
+    const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
+    const mainDbPath = join(basePath, ".gsd", "gsd.db");
+    if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
+      try {
+        const { reconcileWorktreeDb } = await import("./gsd-db.js");
+        reconcileWorktreeDb(mainDbPath, wtDbPath);
+      } catch { /* non-fatal */ }
+    }
+
     try {
       mergeWorktreeToMain(basePath, name, commitMessage);
       ctx.ui.notify(

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -94,7 +94,7 @@ export function worktreeBranchName(name: string): string {
  *
  * @param opts.branch — override the default `worktree/<name>` branch name
  */
-export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string } = {}): WorktreeInfo {
+export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string; reuseExistingBranch?: boolean } = {}): WorktreeInfo {
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new Error(`Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
@@ -133,9 +133,16 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
       );
     }
 
-    // Reset the stale branch to the start point, then attach worktree to it
-    nativeBranchForceReset(basePath, branch, startPoint);
-    nativeWorktreeAdd(basePath, wtPath, branch);
+    if (opts.reuseExistingBranch) {
+      // Attach worktree to the existing branch as-is (preserving commits).
+      // Used when resuming auto-mode: the milestone branch has valid work
+      // from prior sessions that must not be reset.
+      nativeWorktreeAdd(basePath, wtPath, branch);
+    } else {
+      // Reset the stale branch to the start point, then attach worktree to it
+      nativeBranchForceReset(basePath, branch, startPoint);
+      nativeWorktreeAdd(basePath, wtPath, branch);
+    }
   } else {
     nativeWorktreeAdd(basePath, wtPath, branch, true, startPoint);
   }

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

@@ -16,12 +16,14 @@ export interface ResolvedConfig {
 const ENV_KEYS: Record<RemoteChannel, string> = {
   slack: "SLACK_BOT_TOKEN",
   discord: "DISCORD_BOT_TOKEN",
+  telegram: "TELEGRAM_BOT_TOKEN",
 };
 
 // Channel ID format validation — prevents SSRF if preferences are attacker-controlled
 const CHANNEL_ID_PATTERNS: Record<RemoteChannel, RegExp> = {
   slack: /^[A-Z0-9]{9,12}$/,
   discord: /^\d{17,20}$/,
+  telegram: /^-?\d{5,20}$/,
 };
 
 const DEFAULT_TIMEOUT_MINUTES = 5;
@@ -35,7 +37,7 @@ export function resolveRemoteConfig(): ResolvedConfig | null {
   const prefs = loadEffectiveGSDPreferences();
   const rq: RemoteQuestionsConfig | undefined = prefs?.preferences.remote_questions;
   if (!rq || !rq.channel || !rq.channel_id) return null;
-  if (rq.channel !== "slack" && rq.channel !== "discord") return null;
+  if (rq.channel !== "slack" && rq.channel !== "discord" && rq.channel !== "telegram") return null;
 
   const channelId = String(rq.channel_id);
   if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId)) return null;
@@ -59,7 +61,7 @@ export function getRemoteConfigStatus(): string {
   const prefs = loadEffectiveGSDPreferences();
   const rq: RemoteQuestionsConfig | undefined = prefs?.preferences.remote_questions;
   if (!rq || !rq.channel || !rq.channel_id) return "Remote questions: not configured";
-  if (rq.channel !== "slack" && rq.channel !== "discord") return `Remote questions: unknown channel type \"${rq.channel}\"`;
+  if (rq.channel !== "slack" && rq.channel !== "discord" && rq.channel !== "telegram") return `Remote questions: unknown channel type \"${rq.channel}\"`;
   const channelId = String(rq.channel_id);
   if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId)) return `Remote questions: invalid ${rq.channel} channel ID format`;
   const envVar = ENV_KEYS[rq.channel];

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

@@ -3,15 +3,14 @@
  */
 
 import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
-import { formatForDiscord, parseDiscordResponse } from "./format.js";
+import { formatForDiscord, parseDiscordResponse, DISCORD_NUMBER_EMOJIS } from "./format.js";
 
 const DISCORD_API = "https://discord.com/api/v10";
 const PER_REQUEST_TIMEOUT_MS = 15_000;
-const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
-
 export class DiscordAdapter implements ChannelAdapter {
   readonly name = "discord" as const;
   private botUserId: string | null = null;
+  private guildId: string | null = null;
   private readonly token: string;
   private readonly channelId: string;
 
@@ -24,6 +23,17 @@ export class DiscordAdapter implements ChannelAdapter {
     const res = await this.discordApi("GET", "/users/@me");
     if (!res.id) throw new Error("Discord auth failed: invalid token");
     this.botUserId = String(res.id);
+
+    // Resolve guild ID for message URL generation.
+    // The channel belongs to a guild — fetch channel info to discover it.
+    try {
+      const channelInfo = await this.discordApi("GET", `/channels/${this.channelId}`);
+      if (channelInfo.guild_id) {
+        this.guildId = String(channelInfo.guild_id);
+      }
+    } catch {
+      // Non-fatal — message URLs will be omitted if guild ID can't be resolved
+    }
   }
 
   async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
@@ -46,12 +56,18 @@ export class DiscordAdapter implements ChannelAdapter {
       }
     }
 
+    // Build message URL if guild ID is available
+    const messageUrl = this.guildId
+      ? `https://discord.com/channels/${this.guildId}/${this.channelId}/${messageId}`
+      : undefined;
+
     return {
       ref: {
         id: prompt.id,
         channel: "discord",
         messageId,
         channelId: this.channelId,
+        threadUrl: messageUrl,
       },
     };
   }
@@ -67,9 +83,24 @@ export class DiscordAdapter implements ChannelAdapter {
     return this.checkReplies(prompt, ref);
   }
 
+  /**
+   * Acknowledge that an answer was received by adding a ✅ reaction to the
+   * original prompt message. Best-effort — failures are silently ignored.
+   */
+  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
+    try {
+      await this.discordApi(
+        "PUT",
+        `/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent("✅")}/@me`,
+      );
+    } catch {
+      // Best-effort — don't let acknowledgement failures affect the flow
+    }
+  }
+
   private async checkReactions(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
     const reactions: Array<{ emoji: string; count: number }> = [];
-    for (const emoji of NUMBER_EMOJIS) {
+    for (const emoji of DISCORD_NUMBER_EMOJIS) {
       try {
         const users = await this.discordApi("GET", `/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent(emoji)}`);
         if (Array.isArray(users)) {

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,23 +94,29 @@ 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}`;
     });
 
-    const footerText = supportsReactions
-      ? (q.allowMultiple
-          ? "Reply with comma-separated choices (`1,3`) or react with matching numbers"
-          : "Reply with a number or react with the matching number")
-      : `Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`;
+    const footerParts: string[] = [];
+    if (supportsReactions) {
+      footerParts.push(q.allowMultiple
+        ? "Reply with comma-separated choices (`1,3`) or react with matching numbers"
+        : "Reply with a number or react with the matching number");
+    } else {
+      footerParts.push(`Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`);
+    }
+    if (prompt.context?.source) {
+      footerParts.push(`Source: ${prompt.context.source}`);
+    }
 
     return {
       title: q.header,
       description: q.question,
       color: 0x7c3aed,
       fields: [{ name: "Options", value: optionLines.join("\n") }],
-      footer: { text: footerText },
+      footer: { text: footerParts.join(" · ") },
     };
   });
 
@@ -124,8 +160,8 @@ 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
@@ -135,6 +171,122 @@ export function parseDiscordResponse(
   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
+    ? { answers: q.allowMultiple ? picked : [picked[0]] }
+    : { answers: [], user_note: "No clear response via reactions" };
+
+  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 {
@@ -76,6 +77,14 @@ export async function tryRemoteQuestions(
   }
 
   markPromptAnswered(prompt.id, answer);
+
+  // Best-effort acknowledgement gives remote users a visible receipt signal.
+  if (dispatch.ref) {
+    try {
+      await adapter.acknowledgeAnswer?.(dispatch.ref);
+    } catch { /* best-effort */ }
+  }
+
   return {
     content: [{ type: "text", text: JSON.stringify({ answers: formatForTool(answer) }) }],
     details: {
@@ -111,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(
@@ -173,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:",