grok-telegram-bot 2.6.0 → 2.7.0

package/.env.example

@@ -40,6 +40,19 @@ GROK_TRUST_ALL_TOOLS=true
 # Approve/Deny buttons in Telegram.
 AUTO_APPROVE_PERMISSIONS=true
 
+# Auto-approve Grok plan-mode exit (no Approve / Request changes / Abandon).
+# Default true so 24/7 unattended bots never wait. Set false for Telegram review.
+# AUTO_APPROVE_PLAN=true
+
+# Optional Grok agent env (applied on process start / after /restart).
+# GROK_SANDBOX=workspace-safe
+# GROK_MEMORY=
+# GROK_AGENT_PROFILE=
+# GROK_PLUGIN_DIR=
+
+# Named instance slug (same as grok-tg --name). Optional.
+# GROK_TG_NAME=
+
 # Comma-separated roots the /projects browser is allowed to list.
 # Supports ~ for home directory. Defaults to GROK_WORKSPACE's parent + home.
 # Example: H:\Lucru\Domains,C:\Lucru\Domains

package/CHANGELOG.md

@@ -7,6 +7,40 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 The latest section is published verbatim as the GitHub Release notes by
 `.github/workflows/release.yml` when a `vX.Y.Z` tag is pushed.
 
+## [2.7.0] - 2026-08-30
+
+Contributor batch from [@vincenthehna](https://github.com/vincenthehna) (PRs
+#6–#8), ported onto current main and credited here. PR #9 (one process / many
+tokens) was **not** merged: it conflicts with forum General + `TOPIC_GROUP_ID`
+(which bot owns the group?) and with the named-instance model.
+
+### Added
+
+- **Grok Build slash catalog on Telegram** (PR #6 / #7). `/goal`, `/plan`,
+  `/compact`, `/workflow(s)`, `/deep_research`, memory/imagine commands, and
+  other ACP-useful shell builtins are advertised (menu ≤100) and forwarded into
+  the active session (`executeCommand` then prompt fallback). Underscores map
+  to Grok hyphens; collision aliases (`/grok_new`, `/memory_flush`, …) keep
+  bot-owned bare names. `/goal` is refused in **General** (use a project topic
+  or AI Chat). Catch-all forwards unknown Grok/skills slashes.
+- **Named instances** (PR #8). `grok-tg --name work setup|install|status`
+  gives each BotFather token its own `~/.grok/tg/instances/<slug>/` and unique
+  OS service (`grok-telegram-bot-work`). `grok-tg instances` lists them. Default
+  bot and `TELEGRAM_BOT_TOKEN` are unchanged.
+- **Optional interactive plan review** (PR #7). `AUTO_APPROVE_PLAN=false`
+  shows Approve / Request changes / Abandon (timeout still unblocks). Default
+  remains auto-approve so 24/7 unattended bots never wait. `ask_user_question`
+  gets Telegram buttons unless auto-skip is on.
+- **`/sandbox`** plus spawn env: `GROK_SANDBOX`, `GROK_MEMORY`,
+  `--agent-profile`, `--plugin-dir`. `session/new` sets `_meta.yoloMode` when
+  tools are trusted.
+- **CI workflow** (`typecheck` job) so `main` can require status checks.
+
+### Docs
+
+- README / INSTALL: several bots on one host via `--name`.
+- AGENTS.md: CLI instances.
+
 ## [2.6.0] - 2026-08-30
 
 General becomes a chat-like **manager** for the forum group: memory-first
@@ -1001,6 +1035,7 @@ from a single chat and switch between them, on a redesigned, compact menu.
   diffs, MarkdownV2 rendering, scheduled tasks, multi-image prompts, and a
   cross-platform 24/7 background service.
 
+[2.7.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.7.0
 [2.6.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.6.0
 [2.5.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.5.0
 [2.4.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.4.0

package/README.md

@@ -120,8 +120,21 @@ ghost/duplicate that was still polling Telegram (the usual cause of a stale
 "⛔ Not authorized"), so the fresh process with your current `.env` wins. A
 plain `grok-tg run` yields to an already-running background service instead.
 
-Startup options: `grok-tg setup [--path] | run | install | status | logs [n] |
-stop | restart | uninstall`. Or try it without installing: `npx
+Want a **second Telegram bot** (one private chat per project) without switching
+sessions? Create another bot in @BotFather and:
+
+```bash
+grok-tg --name work setup <NEW_BOT_TOKEN> <YOUR_USER_ID>
+grok-tg --name work install
+grok-tg instances
+```
+
+Each named instance has its own `~/.grok/tg/instances/<slug>/` and unique
+service (`grok-telegram-bot-work`). The default bot is unchanged.
+
+Startup options: `grok-tg [--name <slug>] setup [--path] | run | install |
+status | logs [n] | stop | restart | uninstall | instances`. Or try it without
+installing: `npx
 grok-telegram-bot setup`. See **[docs/INSTALL.md](./docs/INSTALL.md)** for the
 full guide.
 

package/docs/INSTALL.md

@@ -56,6 +56,8 @@ grok-tg run                     # run in the foreground (Ctrl-C to stop)
 | `grok-tg logs [n]` | Tail the last `n` log lines (default 100). |
 | `grok-tg stop` / `restart` / `start` | Control the running service. |
 | `grok-tg uninstall` | Stop + remove the background service. |
+| `grok-tg --name <slug> …` | Same commands for a **second Telegram bot** (own token, own chat, own service). |
+| `grok-tg instances` | List the default bot and every named instance. |
 | `grok-tg help` | Show all commands. |
 
 The background service is **user-level** and auto-detected per platform — a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Control the official Grok Build CLI from Telegram over the Agent Client Protocol (ACP). Sign in with your xAI account, switch projects, resume sessions, stream responses with diffs, queue follow-ups, manage multiple sign-ins, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",

package/scripts/setup.mjs

@@ -3,7 +3,8 @@
  * Easy setup: creates/updates the bot's .env, auto-detects the `grok` binary
  * and sensible PROJECT_ROOTS, and optionally writes the bot token / user id:
  *
- *   node scripts/setup.mjs [--path] [--instance <dir>] [<TELEGRAM_BOT_TOKEN> [ALLOWED_USER_ID]]
+ *   node scripts/setup.mjs [--path] [--instance <dir>] [--name <slug>]
+ *                          [<TELEGRAM_BOT_TOKEN> [ALLOWED_USER_ID]]
  *
  * By default the .env lives in the canonical, path-independent home
  * `~/.grok/tg/.env`, so the bot loads the SAME config no matter where it's
@@ -29,8 +30,23 @@ function expandHome(p) {
 function resolveInstanceDir() {
   const flag = process.argv.indexOf("--instance");
   if (flag !== -1 && process.argv[flag + 1]) return resolve(process.argv[flag + 1]);
-  const envDir = (process.env.GROK_TG_DIR || process.env.GROK_TG_CWD || "").trim();
+  const nameEq = process.argv.find((a) => a.startsWith("--name="));
+  const nameFlag = process.argv.indexOf("--name");
+  const name = nameEq
+    ? nameEq.slice("--name=".length)
+    : nameFlag !== -1
+      ? process.argv[nameFlag + 1]
+      : process.env.GROK_TG_NAME;
+  if (name && String(name).trim()) {
+    return join(CANONICAL_DIR, "instances", String(name).trim().toLowerCase());
+  }
+  const envDir = (process.env.GROK_TG_DIR || "").trim();
   if (envDir) return resolve(expandHome(envDir));
+  const cwdHint = (process.env.GROK_TG_CWD || "").trim();
+  if (cwdHint) {
+    const hint = resolve(expandHome(cwdHint));
+    if (existsSync(join(hint, ".env"))) return hint;
+  }
   if (existsSync(join(process.cwd(), ".env"))) return process.cwd();
   return CANONICAL_DIR;
 }
@@ -41,7 +57,8 @@ const positionals = [];
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
   if (a === "--path") pathOnly = true;
-  else if (a === "--instance") i++;
+  else if (a === "--instance" || a === "--name") i++;
+  else if (a.startsWith("--instance=") || a.startsWith("--name=")) continue;
   else positionals.push(a);
 }
 const [tokenArg, userArg] = positionals;

package/src/app/instance.ts

@@ -0,0 +1,223 @@
+/**
+ * Named bot instances: each Telegram bot token gets its own directory
+ * (`.env`, `logs/`, `data/`) and a unique OS service name so several bots
+ * can run 24/7 on one host without overwriting each other.
+ *
+ * The unnamed default stays at `~/.grok/tg` with the original service id.
+ * `grok-tg --name work …` uses `~/.grok/tg/instances/work` and
+ * `grok-telegram-bot-work`.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+
+/** Canonical home for the default (unnamed) instance. */
+export const CANONICAL_DIR = join(homedir(), ".grok", "tg");
+export const INSTANCES_SUBDIR = "instances";
+
+export const DEFAULT_SERVICE_ID = "grok-telegram-bot";
+export const DEFAULT_WINDOWS_TASK = "GrokTelegramBot";
+export const DEFAULT_MACOS_LABEL = "com.grok.telegrambot";
+
+const RESERVED = new Set(["default", "instances", "locks", "logs", "data"]);
+const SLUG_RE = /^[a-z][a-z0-9-]{0,31}$/;
+
+export interface InstanceFlags {
+  instanceDir?: string;
+  name?: string;
+}
+
+export interface ServiceIdentity {
+  id: string;
+  displayName: string;
+  windowsTaskName: string;
+  macosLabel: string;
+  slug?: string;
+}
+
+export interface KnownInstance {
+  /** `(default)` or the instance slug. */
+  name: string;
+  dir: string;
+  slug?: string;
+  identity: ServiceIdentity;
+}
+
+export function expandHome(p: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
+  return p;
+}
+
+export function parseInstanceFlags(argv: string[]): InstanceFlags {
+  const out: InstanceFlags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if ((a === "--instance" || a === "--name") && argv[i + 1]) {
+      const value = argv[++i]!;
+      if (a === "--instance") out.instanceDir = value;
+      else out.name = value;
+      continue;
+    }
+    if (a.startsWith("--instance=")) out.instanceDir = a.slice("--instance=".length);
+    else if (a.startsWith("--name=")) out.name = a.slice("--name=".length);
+  }
+  return out;
+}
+
+/** Drop `--instance` / `--name` (and their values) so the CLI command remains first. */
+export function stripInstanceFlags(argv: string[]): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a === "--instance" || a === "--name") {
+      i++;
+      continue;
+    }
+    if (a.startsWith("--instance=") || a.startsWith("--name=")) continue;
+    out.push(a);
+  }
+  return out;
+}
+
+export function parseInstanceSlug(raw: string): string {
+  const slug = raw.trim().toLowerCase();
+  if (!SLUG_RE.test(slug)) {
+    throw new Error(
+      `Invalid instance name "${raw}". Use 1–32 characters: start with a letter, then letters, digits or hyphens (e.g. work, home, coding).`,
+    );
+  }
+  if (RESERVED.has(slug)) {
+    throw new Error(`Instance name "${slug}" is reserved. Pick another name.`);
+  }
+  return slug;
+}
+
+export function namedInstanceDir(name: string, canonicalDir = CANONICAL_DIR): string {
+  return join(canonicalDir, INSTANCES_SUBDIR, parseInstanceSlug(name));
+}
+
+/**
+ * Resolve this process's instance directory.
+ *
+ * Order: `--instance` → `--name` / `GROK_TG_NAME` → `GROK_TG_DIR` → a
+ * `GROK_TG_CWD` or cwd that already contains `.env` → `~/.grok/tg`.
+ *
+ * `GROK_TG_CWD` is only a "user launched from here" hint (the `grok-tg`
+ * launcher always sets it). It must not override `--name`, otherwise a
+ * named instance could never be selected.
+ */
+export function resolveInstanceDir(opts: {
+  argv?: string[];
+  envDir?: string;
+  nameEnv?: string;
+  cwdHint?: string;
+  cwd?: string;
+  canonicalDir?: string;
+} = {}): string {
+  const canonicalDir = opts.canonicalDir ?? CANONICAL_DIR;
+  const cwd = opts.cwd ?? process.cwd();
+  const flags = parseInstanceFlags(opts.argv ?? process.argv);
+  if (flags.instanceDir?.trim()) return resolve(expandHome(flags.instanceDir.trim()));
+  const name = flags.name?.trim() || opts.nameEnv?.trim();
+  if (name) return namedInstanceDir(name, canonicalDir);
+  if (opts.envDir?.trim()) return resolve(expandHome(opts.envDir.trim()));
+  const hinted = opts.cwdHint?.trim();
+  if (hinted) {
+    const hint = resolve(expandHome(hinted));
+    if (existsSync(join(hint, ".env"))) return hint;
+  }
+  if (existsSync(join(cwd, ".env"))) return cwd;
+  return canonicalDir;
+}
+
+/**
+ * OS service names for this instance.
+ *
+ * Unique names are used only for `--name` / `~/.grok/tg/instances/<slug>` so
+ * an existing default install (`grok-telegram-bot.service`) is unchanged.
+ * A random folder with a `.env` keeps the default service id.
+ */
+export function serviceIdentity(
+  instanceDir: string,
+  name?: string,
+  canonicalDir = CANONICAL_DIR,
+): ServiceIdentity {
+  const slug = name?.trim()
+    ? parseInstanceSlug(name)
+    : inferNamedInstanceSlug(instanceDir, canonicalDir);
+  if (!slug) {
+    return {
+      id: DEFAULT_SERVICE_ID,
+      displayName: "Grok Telegram Bot",
+      windowsTaskName: DEFAULT_WINDOWS_TASK,
+      macosLabel: DEFAULT_MACOS_LABEL,
+    };
+  }
+  return {
+    id: `${DEFAULT_SERVICE_ID}-${slug}`,
+    displayName: `Grok Telegram Bot (${slug})`,
+    windowsTaskName: `${DEFAULT_WINDOWS_TASK}-${slug}`,
+    macosLabel: `${DEFAULT_MACOS_LABEL}.${slug}`,
+    slug,
+  };
+}
+
+export function listKnownInstances(canonicalDir = CANONICAL_DIR): KnownInstance[] {
+  const out: KnownInstance[] = [];
+  if (existsSync(join(canonicalDir, ".env"))) {
+    out.push({
+      name: "(default)",
+      dir: canonicalDir,
+      identity: serviceIdentity(canonicalDir, undefined, canonicalDir),
+    });
+  }
+  const root = join(canonicalDir, INSTANCES_SUBDIR);
+  if (!existsSync(root)) return out;
+  let names: string[] = [];
+  try {
+    names = readdirSync(root, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .sort();
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    const dir = join(root, name);
+    if (!existsSync(join(dir, ".env"))) continue;
+    out.push({
+      name,
+      dir,
+      slug: name,
+      identity: serviceIdentity(dir, undefined, canonicalDir),
+    });
+  }
+  return out;
+}
+
+/** Basename when `instanceDir` is a direct child of `<canonical>/instances`. */
+function namedChildName(instanceDir: string, canonicalDir: string): string | undefined {
+  const resolved = resolve(instanceDir);
+  const parent = resolve(join(resolved, ".."));
+  const root = resolve(join(canonicalDir, INSTANCES_SUBDIR));
+  if (parent !== root) return undefined;
+  return basename(resolved);
+}
+
+function inferNamedInstanceSlug(instanceDir: string, canonicalDir: string): string | undefined {
+  const child = namedChildName(instanceDir, canonicalDir);
+  if (!child) return undefined;
+  try {
+    return parseInstanceSlug(child);
+  } catch {
+    const fallback = child
+      .toLowerCase()
+      .replace(/[^a-z0-9-]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 32);
+    return fallback && SLUG_RE.test(fallback) && !RESERVED.has(fallback) ? fallback : "extra";
+  }
+}

package/src/app/types.ts

@@ -97,6 +97,11 @@ export interface PromptInput {
    * "Thinking…" then streams the agent reply into.
    */
   seedMessageId?: number;
+  /**
+   * Grok Build slash command (`/goal`, `/compact`, …). Must stay the first
+   * line of the prompt — skip manager/complexity wrappers.
+   */
+  rawSlashCommand?: boolean;
 }
 
 export function textPrompt(
@@ -108,6 +113,7 @@ export function textPrompt(
     promptId?: string;
     reportBack?: PromptInput["reportBack"];
     seedMessageId?: number;
+    rawSlashCommand?: boolean;
   },
 ): PromptInput {
   return {
@@ -120,5 +126,6 @@ export function textPrompt(
     skipSelfRecheck: opts?.skipSelfRecheck,
     reportBack: opts?.reportBack,
     seedMessageId: opts?.seedMessageId,
+    rawSlashCommand: opts?.rawSlashCommand,
   };
 }

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 : "";
+}