grok-telegram-bot 2.5.0 → 2.7.0

package/src/bot/ask-user-service.ts

@@ -0,0 +1,226 @@
+/**
+ * Interactive Grok `ask_user_question` reverse requests.
+ * Headless default used to skip; we now present options as Telegram buttons.
+ */
+import type { Api } from "grammy";
+import { InlineKeyboard } from "grammy";
+import { outboundThreadExtra } from "../forum/thread.js";
+import { createLogger } from "../logger.js";
+import type { RuntimeRegistry } from "./registry.js";
+
+const log = createLogger("ask-user");
+const TIMEOUT_MS = 30 * 60 * 1000;
+
+export interface InterviewQuestion {
+  id: string;
+  prompt: string;
+  options: Array<{ id: string; label: string }>;
+  multi: boolean;
+}
+
+/** ACP reverse-request result (externally tagged enum, smoke-verified skip). */
+export type AskUserResult =
+  | { SkipInterview: null }
+  | { SubmitAnswers: { answers: Array<{ questionId: string; selected: string[] }> } };
+
+interface Pending {
+  resolve: (r: AskUserResult) => void;
+  chatId: number;
+  messageId?: number;
+  questions: InterviewQuestion[];
+  picked: Map<string, Set<string>>;
+  index: number;
+  timer: NodeJS.Timeout;
+}
+
+export class AskUserService {
+  private readonly pending = new Map<string, Pending>();
+  private seq = 0;
+
+  constructor(
+    private readonly api: Api,
+    private readonly registry: RuntimeRegistry,
+    public autoSkip = false,
+  ) {}
+
+  async handle(params: Record<string, unknown>): Promise<AskUserResult> {
+    const questions = parseQuestions(params);
+    const sessionId = str(params.sessionId) || str(params.session_id) || "";
+    if (this.autoSkip || questions.length === 0) {
+      log.info(`skip ask_user_question (${questions.length} q)`);
+      return { SkipInterview: null };
+    }
+    const desc = sessionId ? this.registry.describeSession(sessionId) : { chatId: undefined };
+    const chatId = desc.chatId;
+    if (chatId === undefined) return { SkipInterview: null };
+    const threadExtra = outboundThreadExtra(desc.threadId);
+
+    const reqId = String(++this.seq);
+    const picked = new Map<string, Set<string>>();
+    for (const q of questions) picked.set(q.id, new Set());
+
+    try {
+      const msg = await this.api.sendMessage(chatId, renderQuestion(questions, 0, picked), {
+        reply_markup: questionKeyboard(reqId, questions[0]!, picked.get(questions[0]!.id)!),
+        disable_notification: false,
+        ...threadExtra,
+      });
+      return new Promise<AskUserResult>((resolve) => {
+        const timer = setTimeout(() => {
+          const p = this.pending.get(reqId);
+          if (!p) return;
+          this.pending.delete(reqId);
+          void this.api.editMessageText(p.chatId, p.messageId ?? 0, "\u231B Question timed out \u2014 skipped.").catch(
+            () => {},
+          );
+          resolve({ SkipInterview: null });
+        }, TIMEOUT_MS);
+        this.pending.set(reqId, {
+          resolve,
+          chatId,
+          messageId: msg.message_id,
+          questions,
+          picked,
+          index: 0,
+          timer,
+        });
+      });
+    } catch (e) {
+      log.warn("send ask_user failed:", (e as Error).message);
+      return { SkipInterview: null };
+    }
+  }
+
+  tap(reqId: string, kind: string, value?: string): string | undefined {
+    const p = this.pending.get(reqId);
+    if (!p) return undefined;
+    const q = p.questions[p.index];
+    if (!q) return undefined;
+
+    if (kind === "skip") {
+      this.settle(p, reqId, { SkipInterview: null }, "\u23ED Skipped questions.");
+      return "Skipped";
+    }
+    if (kind === "opt" && value !== undefined) {
+      const opt = q.options[Number(value)];
+      if (!opt) return "Expired";
+      const set = p.picked.get(q.id)!;
+      if (q.multi) {
+        if (set.has(opt.id)) set.delete(opt.id);
+        else set.add(opt.id);
+      } else {
+        set.clear();
+        set.add(opt.id);
+      }
+      void this.redraw(reqId, p);
+      return q.multi ? "Toggled" : "Selected";
+    }
+    if (kind === "next") {
+      if (p.index < p.questions.length - 1) {
+        p.index += 1;
+        void this.redraw(reqId, p);
+        return "Next";
+      }
+      const answers = p.questions.map((qq) => ({
+        questionId: qq.id,
+        selected: [...(p.picked.get(qq.id) ?? [])],
+      }));
+      this.settle(p, reqId, { SubmitAnswers: { answers } }, "\u2705 Answers sent.");
+      return "Submitted";
+    }
+    if (kind === "prev" && p.index > 0) {
+      p.index -= 1;
+      void this.redraw(reqId, p);
+      return "Back";
+    }
+    return undefined;
+  }
+
+  private async redraw(reqId: string, p: Pending): Promise<void> {
+    const q = p.questions[p.index]!;
+    const set = p.picked.get(q.id)!;
+    if (p.messageId === undefined) return;
+    await this.api
+      .editMessageText(p.chatId, p.messageId, renderQuestion(p.questions, p.index, p.picked), {
+        reply_markup: questionKeyboard(reqId, q, set, p.index, p.questions.length),
+      })
+      .catch(() => {});
+  }
+
+  private settle(p: Pending, reqId: string, result: AskUserResult, text: string): void {
+    clearTimeout(p.timer);
+    this.pending.delete(reqId);
+    if (p.messageId !== undefined) {
+      void this.api.editMessageText(p.chatId, p.messageId, text, { reply_markup: { inline_keyboard: [] } }).catch(
+        () => {},
+      );
+    }
+    p.resolve(result);
+  }
+}
+
+export function parseQuestions(params: Record<string, unknown>): InterviewQuestion[] {
+  const raw = params.questions ?? params.questionnaire ?? params.items;
+  if (!Array.isArray(raw)) return [];
+  const out: InterviewQuestion[] = [];
+  raw.forEach((item, i) => {
+    if (!item || typeof item !== "object") return;
+    const o = item as Record<string, unknown>;
+    const prompt = str(o.question) || str(o.prompt) || str(o.header) || str(o.text) || `Question ${i + 1}`;
+    const id = str(o.id) || str(o.questionId) || `q${i}`;
+    const multi = o.multiSelect === true || o.multi === true || o.allow_multiple === true;
+    const optsRaw = Array.isArray(o.options) ? o.options : [];
+    const options = optsRaw
+      .map((opt, j) => {
+        if (typeof opt === "string") return { id: opt, label: opt };
+        if (!opt || typeof opt !== "object") return undefined;
+        const oo = opt as Record<string, unknown>;
+        const label = str(oo.label) || str(oo.name) || str(oo.text) || `Option ${j + 1}`;
+        const oid = str(oo.id) || str(oo.value) || label;
+        return { id: oid, label };
+      })
+      .filter((x): x is { id: string; label: string } => Boolean(x));
+    if (options.length === 0) options.push({ id: "yes", label: "Yes" }, { id: "no", label: "No" });
+    out.push({ id, prompt, options, multi });
+  });
+  return out;
+}
+
+function renderQuestion(
+  questions: InterviewQuestion[],
+  index: number,
+  picked: Map<string, Set<string>>,
+): string {
+  const q = questions[index]!;
+  const set = picked.get(q.id) ?? new Set();
+  const lines = [
+    `\u2753 Grok has a question (${index + 1}/${questions.length})`,
+    "",
+    q.prompt,
+    q.multi ? "\n(multi-select \u2014 tap to toggle, then Next)" : "",
+    set.size ? `\nSelected: ${[...set].join(", ")}` : "",
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+
+function questionKeyboard(
+  reqId: string,
+  q: InterviewQuestion,
+  selected: Set<string>,
+  index = 0,
+  total = 1,
+): InlineKeyboard {
+  const kb = new InlineKeyboard();
+  q.options.slice(0, 12).forEach((opt, j) => {
+    const mark = selected.has(opt.id) ? "\u2705 " : "";
+    kb.text(`${mark}${opt.label.slice(0, 40)}`, `asku:${reqId}:opt:${j}`).row();
+  });
+  if (index > 0) kb.text("\u25C0 Back", `asku:${reqId}:prev`);
+  kb.text(index < total - 1 ? "Next \u25B6" : "\u2705 Submit", `asku:${reqId}:next`);
+  kb.row().text("Skip", `asku:${reqId}:skip`);
+  return kb;
+}
+
+function str(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}

package/src/bot/auth.ts

@@ -112,7 +112,11 @@ async function denyUnauthorized(
   }
   if (!ctx.chat || isGroupChat(ctx)) return; // groups: ignore quietly
   const threadId = m && "message_thread_id" in m ? m.message_thread_id : undefined;
-  const extra = threadId !== undefined ? { message_thread_id: threadId as number } : {};
+  // Omit General (1) — Bot API rejects message_thread_id=1.
+  const extra =
+    threadId !== undefined && threadId !== 1
+      ? { message_thread_id: threadId as number }
+      : {};
   await ctx
     .reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID to ALLOWED_USERS.", extra)
     .catch(() => {});

package/src/bot/bot.ts

@@ -44,6 +44,9 @@ import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
 import { registerVoice } from "./handlers/voice.js";
 import { registerForum } from "./handlers/forum.js";
+import { registerGrokSlash } from "./handlers/grok-slash.js";
+import { AskUserService } from "./ask-user-service.js";
+import { PlanExitService } from "./plan-exit-service.js";
 import { StatusPanel } from "./menu/status-panel.js";
 import { sendMarkdownDoc } from "./telegram-io.js";
 import { Ephemeral } from "./menu/ephemeral.js";
@@ -116,21 +119,58 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     forum,
     bots: telegramBots,
     // Cross-topic orchestration: General can create a topic and send_prompt there.
-    submitTopicPrompt: async ({ threadId, cwd, projectName, prompt, newSession }) => {
+    // sessionId resumes a specific Grok session (memory follow-up) instead of
+    // dumping into whatever is currently open in that topic.
+    submitTopicPrompt: async ({
+      threadId,
+      cwd,
+      projectName,
+      prompt,
+      newSession,
+      sessionId,
+      reportBack,
+    }) => {
       if (cfg.topicGroupId === undefined) {
         throw new Error("TOPIC_GROUP_ID unset");
       }
       const groupId = cfg.topicGroupId;
       const controller = registry.forumController(groupId, threadId, cwd, projectName);
+      // Explicit resume wins over newSession / foreground.
+      if (sessionId) {
+        const sw = await controller.addResume(sessionId, cwd, projectName);
+        if (reportBack) sw.rt.setReportBack(reportBack);
+        const outcome = await sw.rt.submit(textPrompt(prompt));
+        return { outcome, sessionId: sw.rt.sessionId ?? sessionId };
+      }
       if (newSession) {
         const rt = await controller.addNew(cwd, projectName);
+        if (reportBack) rt.setReportBack(reportBack);
         const outcome = await rt.submit(textPrompt(prompt));
         return { outcome, sessionId: rt.sessionId };
       }
       const rt = controller.foreground();
+      if (reportBack) rt.setReportBack(reportBack);
       const outcome = await rt.submit(textPrompt(prompt));
       return { outcome, sessionId: rt.sessionId };
     },
+    // Child topic Done → wake General manager with a WORK REPORT.
+    wakeManager: async ({ originChatId, originThreadId, prompt }) => {
+      if (cfg.topicGroupId === undefined) {
+        throw new Error("TOPIC_GROUP_ID unset");
+      }
+      const groupId = cfg.topicGroupId;
+      // origin is always General in manager mode; bind workspace.
+      const controller = registry.forumController(
+        originChatId || groupId,
+        originThreadId,
+        cfg.workspace,
+        "General",
+      );
+      const rt = controller.foreground();
+      await rt.submit(
+        textPrompt(prompt, undefined, undefined, { skipSelfRecheck: true }),
+      );
+    },
   });
 
   const deps: BotDeps = {
@@ -170,6 +210,18 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     onUnpinned: (chatId) => statusPanel.ensurePinned(chatId),
   });
   acp.permissionHandler = (p) => permissions.handle(p);
+
+  const planExit = new PlanExitService(bot.api, registry, cfg.autoApprovePlan, (chatId) =>
+    statusPanel.ensurePinned(chatId),
+  );
+  acp.planExitHandler = (params) => planExit.handle(params);
+
+  const askUser = new AskUserService(
+    bot.api,
+    registry,
+    cfg.autoApprovePlan && cfg.autoApprovePermissions,
+  );
+  acp.askUserHandler = (params) => askUser.handle(params);
   // /stop and /cancel must cancel pending interactive permissions for that
   // session only (ACP requires cancelled outcomes) — never kill the agent.
   acp.onSessionCancel = (sessionId) => {
@@ -215,6 +267,16 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     if (sid) await switchAndShow(ctx, deps, sid);
   });
 
+  bot.callbackQuery(/^planx:(\d+):(ok|chg|no)$/, async (ctx) => {
+    const toast = planExit.resolveChoice(ctx.match![1]!, ctx.match![2]!);
+    await ctx.answerCallbackQuery({ text: toast ?? "Expired" });
+  });
+
+  bot.callbackQuery(/^asku:(\d+):(opt|next|prev|skip)(?::(.*))?$/, async (ctx) => {
+    const toast = askUser.tap(ctx.match![1]!, ctx.match![2]!, ctx.match![3]);
+    await ctx.answerCallbackQuery({ text: toast ?? "Expired" });
+  });
+
   // Legacy complexity buttons (removed — agent decides; auto-plan if complex).
   bot.callbackQuery(/^cplx:(simple|complex)$/, async (ctx) => {
     await ctx.answerCallbackQuery({ text: "Complexity is automatic now" });
@@ -231,18 +293,50 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     const index = Number(ctx.match![2]);
     const { resolveScope } = await import("./scope.js");
     const { adoptUserPrompt } = await import("./prompt-anchor.js");
+    const { isGeneralThread } = await import("../forum/thread.js");
     const scope = resolveScope(ctx, deps);
-    const rt = scope.rt;
-    const text = rt.takeSuggestion(batchId, index);
-    if (!text) {
+    // General may have parallel sessions — find the runtime that owns this batch.
+    const hit =
+      scope.controller.takeSuggestionAnywhere(batchId, index) ??
+      (() => {
+        const t = scope.rt.takeSuggestion(batchId, index);
+        return t ? { rt: scope.rt, text: t } : undefined;
+      })();
+    if (!hit) {
       await ctx.answerCallbackQuery({ text: "Suggestion expired", show_alert: true });
       return;
     }
+    const { rt, text } = hit;
     await ctx.answerCallbackQuery({ text: "Sending\u2026" });
     // Dim the keyboard so double-taps don't re-fire.
     await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } }).catch(() => {});
     try {
       const chatId = ctx.chat?.id;
+      const isGeneral = isGeneralThread(scope.threadId);
+      const sugMsgId = ctx.callbackQuery.message?.message_id;
+      // General: keep chat clean — no anchor overwrite; continue same session
+      // and reply to the message that carried the buttons.
+      if (isGeneral) {
+        if (rt.sessionId && sugMsgId !== undefined) {
+          scope.controller.bindTelegramMessage(sugMsgId, rt.sessionId);
+        }
+        const outcome = await rt.submit(
+          textPrompt(text, sugMsgId, undefined, { promptId: undefined }),
+        );
+        if (outcome === "queued") {
+          const extra: Record<string, unknown> = { ...scope.threadExtra };
+          if (sugMsgId !== undefined) {
+            extra.reply_parameters = {
+              message_id: sugMsgId,
+              allow_sending_without_reply: true,
+            };
+          }
+          await deps.api
+            .sendMessage(chatId!, "\u{1F4E5} Queued on that thread.", extra)
+            .catch(() => {});
+        }
+        return;
+      }
       const anchor =
         chatId !== undefined
           ? await adoptUserPrompt(deps.api, {
@@ -280,6 +374,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
 
   registerMenu(bot, deps); // persistent-keyboard buttons (hears)
   registerWizardInput(bot, deps); // wizard text input (before commands)
+  bot.on("message:text", async (ctx, next) => {
+    const text = ctx.message?.text ?? "";
+    if (!text || text.startsWith("/")) return next();
+    if (planExit.takeFeedback(ctx.chat.id, text)) return;
+    await next();
+  });
   if (forum) registerForum(bot, deps, forum);
   registerControl(bot, deps);
   registerProjects(bot, deps);
@@ -298,6 +398,7 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   registerPhotos(bot, deps); // photos & image documents
   registerDocuments(bot, deps); // non-image files (text inlined, binaries saved)
   registerVoice(bot, deps); // voice / audio -> transcription -> prompt
+  registerGrokSlash(bot, deps); // Grok Build /goal /plan /compact … + catch-all
   registerMessages(bot, deps); // catch-all text prompt — keep last
 
   bot.catch((err) => {

package/src/bot/chat-controller.ts

@@ -63,6 +63,12 @@ export class ChatController {
   /** Telegram bridge (forum / memory / sibling bots); set by the registry. */
   bridge?: ChatBridgeServices;
 
+  /**
+   * General manager: map Telegram message ids (user + bot) → session id so a
+   * reply-to continues the same ACP session instead of spawning a new one.
+   */
+  private readonly telegramMsgSessions = new Map<number, string>();
+
   constructor(
     private readonly api: Api,
     private readonly chatId: number,
@@ -128,6 +134,105 @@ export class ChatController {
     return rt;
   }
 
+  /**
+   * General manager: spawn a fresh session for one user message without
+   * killing an in-flight sibling's Telegram stream (parallel prompts).
+   */
+  async addParallel(cwd: string, projectName?: string): Promise<SessionRuntime> {
+    return this.addNew(cwd, projectName);
+  }
+
+  /** Remember that a Telegram message belongs to a Grok session (reply routing). */
+  bindTelegramMessage(messageId: number, sessionId: string): void {
+    if (!messageId || !sessionId) return;
+    this.telegramMsgSessions.set(messageId, sessionId);
+    // Cap map growth (keep newest ~500).
+    if (this.telegramMsgSessions.size > 500) {
+      const drop = this.telegramMsgSessions.size - 500;
+      let i = 0;
+      for (const k of this.telegramMsgSessions.keys()) {
+        this.telegramMsgSessions.delete(k);
+        if (++i >= drop) break;
+      }
+    }
+  }
+
+  /** Resolve a controlled runtime from a Telegram message id (reply-to). */
+  runtimeForTelegramMessage(messageId: number | undefined): SessionRuntime | undefined {
+    if (messageId === undefined) return undefined;
+    this.ensureRestored();
+    const sid = this.telegramMsgSessions.get(messageId);
+    if (sid) {
+      const byId = this.runtimes.find((r) => r.sessionId === sid);
+      if (byId) return byId;
+    }
+    return undefined;
+  }
+
+  /**
+   * Resolve session from `#sess_xxxxxxxx` in a replied-to bot message body
+   * (works across process restarts when the in-memory map is cold).
+   */
+  runtimeForSessionTag(text: string | undefined): SessionRuntime | undefined {
+    if (!text) return undefined;
+    this.ensureRestored();
+    const tag = parseSessTag(text);
+    if (!tag) return undefined;
+    return this.runtimes.find((r) => r.sessionId && sessionMatchesTag(r.sessionId, tag));
+  }
+
+  /**
+   * Cold-start / map-miss: resolve continue target from reply message id, #sess_
+   * tag on controlled runtimes, or disk session list (attach into this controller).
+   */
+  async resolveContinueFromReply(opts: {
+    replyToMessageId?: number;
+    replyToText?: string;
+    cwd: string;
+    projectName?: string;
+  }): Promise<SessionRuntime | undefined> {
+    this.ensureRestored();
+    const byMsg = this.runtimeForTelegramMessage(opts.replyToMessageId);
+    if (byMsg) return byMsg;
+    const byTag = this.runtimeForSessionTag(opts.replyToText);
+    if (byTag) return byTag;
+
+    const tag = parseSessTag(opts.replyToText);
+    if (!tag) return undefined;
+    // Disk fallback: find full session id, then resume into this controller.
+    let metas;
+    try {
+      metas = this.store.list(80);
+    } catch {
+      return undefined;
+    }
+    const meta = metas.find((m) => sessionMatchesTag(m.sessionId, tag));
+    if (!meta) return undefined;
+    try {
+      const sw = await this.addResume(
+        meta.sessionId,
+        meta.cwd || opts.cwd,
+        opts.projectName,
+      );
+      return sw.rt;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Find any runtime that still holds this suggestion batch (General parallel). */
+  takeSuggestionAnywhere(
+    batchId: number,
+    index: number,
+  ): { rt: SessionRuntime; text: string } | undefined {
+    this.ensureRestored();
+    for (const r of this.runtimes) {
+      const text = r.takeSuggestion(batchId, index);
+      if (text) return { rt: r, text };
+    }
+    return undefined;
+  }
+
   /**
    * Switch the chat to a project directory **without** waiting on ACP.
    * - Reuses an existing controlled runtime for the same path when possible.
@@ -410,6 +515,9 @@ export class ChatController {
       this.markSeen(rt);
       this.persist();
     };
+    rt.onTelegramMessageBound = (messageId, sessionId) => {
+      this.bindTelegramMessage(messageId, sessionId);
+    };
     return rt;
   }
 
@@ -466,3 +574,24 @@ export class ChatController {
 function normPath(p: string): string {
   return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
+
+/** Extract `#sess_xxxxxxxx` from bot message text/caption. */
+function parseSessTag(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const m = text.match(/#sess_([a-z0-9]{6,12})/i);
+  return m?.[1]?.toLowerCase();
+}
+
+/** Match full session UUID (or short form) to a #sess_ tag body. */
+function sessionMatchesTag(sessionId: string, tag: string): boolean {
+  const compact = sessionId.replace(/-/g, "").toLowerCase();
+  const short = sessionId.slice(0, 8).replace(/[^a-z0-9]/gi, "").toLowerCase();
+  const t = tag.toLowerCase();
+  return (
+    short === t ||
+    short.startsWith(t) ||
+    t.startsWith(short) ||
+    compact.startsWith(t) ||
+    sessionId.toLowerCase().startsWith(t)
+  );
+}

package/src/bot/commands.ts

@@ -5,8 +5,10 @@
  * a shorter list with cancel/menu first — reply keyboards are unreliable there.
  */
 
-/** Full command menu (private chats + default). Order = Telegram "/" menu order. */
-export const COMMANDS: { command: string; description: string }[] = [
+import { GROK_FORWARDED_COMMANDS } from "./handlers/grok-slash.js";
+
+/** Bot-local commands (not forwarded to Grok). Order = Telegram "/" menu order. */
+export const BOT_COMMANDS: { command: string; description: string }[] = [
   // Core control
   { command: "start", description: "Welcome, menu & status panel" },
   { command: "menu", description: "Open the menu" },
@@ -37,10 +39,17 @@ export const COMMANDS: { command: string; description: string }[] = [
   { command: "killall", description: "Kill all active sessions on the PC" },
   { command: "model", description: "Switch model: /model <id>" },
   { command: "restart", description: "Restart the Grok agent" },
+  { command: "sandbox", description: "Show / set Grok sandbox profile" },
   { command: "unwatch", description: "Stop following a live session" },
   { command: "help", description: "Show help" },
 ];
 
+/** Full Telegram menu: bot-local + Grok Build shell forwards (≤100). */
+export const COMMANDS: { command: string; description: string }[] = [
+  ...BOT_COMMANDS,
+  ...GROK_FORWARDED_COMMANDS.map(({ command, description }) => ({ command, description })),
+];
+
 /**
  * Group / forum command menu — keep short; cancel & menu first so topics can
  * stop a turn without the private reply-keyboard bar.
@@ -56,6 +65,9 @@ export const GROUP_COMMANDS: { command: string; description: string }[] = [
   { command: "btw", description: "Queue or run: /btw <text>" },
   { command: "flush", description: "Run queued follow-ups now" },
   { command: "model", description: "Switch model: /model <id>" },
+  { command: "goal", description: "Grok /goal — run until done" },
+  { command: "plan", description: "Grok /plan — enter plan mode" },
+  { command: "compact", description: "Grok /compact — compress context" },
   { command: "help", description: "Show help" },
 ];
 
@@ -91,4 +103,12 @@ export const HELP_TEXT = [
   "/flush \u2014 run queued follow-ups immediately",
   "/reauth \u2014 sign in to Grok",
   "/accounts \u2014 switch saved Grok accounts",
+  "/sandbox \u2014 show or set GROK_SANDBOX (needs /restart)",
+  "",
+  "GROK BUILD SLASH (forwarded into the active session)",
+  "/goal /plan /view_plan /compact /context /session_info",
+  "/deep_research /workflow /workflows /loop",
+  "/remember /memory /memory_flush /dream",
+  "Underscores map to hyphens (e.g. /view_plan \u2192 /view-plan).",
+  "Other non-bot Grok /commands and skills are also forwarded.",
 ].join("\n");