grok-telegram-bot 2.4.0 → 2.5.0

package/src/bot/chat-controller.ts

@@ -23,10 +23,7 @@ export interface RunningSession {
   unread: number;
   /** Latest task-completion % (0–100) for this session, if known. */
   progress?: number;
-  /**
-   * Card comment: live step while working, chat summary when idle
-   * ("what is happening / what was done").
-   */
+  /** Card comment: last user prompt (+ last AI thinking while busy). */
   comment?: string;
 }
 
@@ -40,11 +37,31 @@ export interface SwitchResult {
   alreadyForeground: boolean;
 }
 
+export interface ChatControllerOpts {
+  /** Forum topic thread — all runtimes post into this topic. */
+  messageThreadId?: number;
+  /** Settings key (`chatId` or `chatId:t{thread}`). Defaults to String(chatId). */
+  settingsKey?: string;
+  /** Fixed project path (forum topics): never switch away via project picker. */
+  fixedCwd?: string;
+  fixedProjectName?: string;
+}
+
+/** Optional Telegram bridge services attached to every runtime in this chat. */
+export type ChatBridgeServices = SessionRuntime["bridge"];
+
 export class ChatController {
   private readonly runtimes: SessionRuntime[] = [];
   private fg: SessionRuntime | undefined;
   private readonly lastRead = new Map<string, number>();
   private restored = false;
+  readonly settingsKey: string;
+  readonly messageThreadId: number | undefined;
+  readonly fixedCwd: string | undefined;
+  readonly fixedProjectName: string | undefined;
+
+  /** Telegram bridge (forum / memory / sibling bots); set by the registry. */
+  bridge?: ChatBridgeServices;
 
   constructor(
     private readonly api: Api,
@@ -56,14 +73,22 @@ export class ChatController {
     private readonly refresh: (chatId: number) => void,
     private readonly notifyActivity: (busy: boolean) => void,
     private readonly getRotator?: () => AccountRotator | undefined,
-  ) {}
+    opts?: ChatControllerOpts,
+  ) {
+    this.messageThreadId = opts?.messageThreadId;
+    this.settingsKey = opts?.settingsKey ?? String(chatId);
+    this.fixedCwd = opts?.fixedCwd;
+    this.fixedProjectName = opts?.fixedProjectName;
+  }
 
   /** The current foreground runtime (created/restored lazily). */
   foreground(): SessionRuntime {
     this.ensureRestored();
     if (!this.fg) {
-      const s = this.settings.get(this.chatId);
-      const rt = this.create({ cwd: s.projectPath ?? this.cfg.workspace, projectName: s.projectName, sessionId: s.sessionId });
+      const s = this.settings.getKey(this.settingsKey);
+      const cwd = this.fixedCwd ?? s.projectPath ?? this.cfg.workspace;
+      const name = this.fixedProjectName ?? s.projectName;
+      const rt = this.create({ cwd, projectName: name, sessionId: s.sessionId });
       this.runtimes.push(rt);
       this.fg = rt;
     }
@@ -279,7 +304,7 @@ export class ChatController {
     return this.runtimes.find((r) => r.sessionId === sessionId)?.taskProgress;
   }
 
-  /** Live step / chat summary for a controlled session id. */
+  /** Last user prompt (+ thinking when busy) for a controlled session id. */
   commentFor(sessionId?: string): string | undefined {
     if (!sessionId) return undefined;
     this.ensureRestored();
@@ -301,27 +326,31 @@ export class ChatController {
   private ensureRestored(): void {
     if (this.restored) return;
     this.restored = true;
-    const s = this.settings.get(this.chatId);
+    const s = this.settings.getKey(this.settingsKey);
     const seen = new Set<string>();
     for (const cs of s.controlledSessions ?? []) {
       if (!cs.sessionId || seen.has(cs.sessionId)) continue; // never restore the same session twice
       seen.add(cs.sessionId);
+      // Forum topics only restore sessions for the fixed project path.
+      if (this.fixedCwd && normPath(cs.projectPath) !== normPath(this.fixedCwd)) continue;
       this.runtimes.push(this.create({ cwd: cs.projectPath, projectName: cs.projectName, sessionId: cs.sessionId }));
     }
     // Lazy project switches persist projectPath without a sessionId. If the
     // saved project is not among controlled sessions, recreate an unbound FG
     // so a restart lands on the project the user last chose.
-    if (s.projectPath) {
-      const key = normPath(s.projectPath);
+    const homePath = this.fixedCwd ?? s.projectPath;
+    const homeName = this.fixedProjectName ?? s.projectName;
+    if (homePath) {
+      const key = normPath(homePath);
       const hasProject = this.runtimes.some((r) => normPath(r.cwd) === key);
       if (!hasProject) {
-        this.runtimes.push(this.create({ cwd: s.projectPath, projectName: s.projectName }));
+        this.runtimes.push(this.create({ cwd: homePath, projectName: homeName, sessionId: s.sessionId }));
       }
     }
     if (this.runtimes.length > 0) {
       let fg = this.runtimes.find((r) => r.sessionId && r.sessionId === s.foregroundSessionId);
-      if (!fg && s.projectPath) {
-        const key = normPath(s.projectPath);
+      if (!fg && homePath) {
+        const key = normPath(homePath);
         fg = this.runtimes.find((r) => normPath(r.cwd) === key);
       }
       fg = fg ?? this.runtimes[0]!;
@@ -365,10 +394,15 @@ export class ChatController {
   }
 
   private create(init: { cwd: string; projectName?: string; sessionId?: string }): SessionRuntime {
-    const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, init);
+    const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, {
+      ...init,
+      messageThreadId: this.messageThreadId,
+      settingsKey: this.settingsKey,
+    });
     rt.onStateChange = () => this.refresh(this.chatId);
     rt.onActivity = (busy) => this.notifyActivity(busy);
     rt.accountRotator = this.getRotator?.();
+    rt.bridge = this.bridge;
     // A logical fork (auto-fork-on-error / lost-session recovery) swaps the
     // runtime's session id in place — re-persist the controlled list with the
     // new id and treat the fresh session as already-seen.
@@ -415,15 +449,15 @@ export class ChatController {
       seen.add(r.sessionId);
       controlled.push({ sessionId: r.sessionId, projectPath: r.cwd, projectName: r.projectName });
     }
-    this.settings.update(this.chatId, {
+    this.settings.updateKey(this.settingsKey, {
       controlledSessions: controlled,
       foregroundSessionId: this.fg?.sessionId,
       // Keep the single-session restore fields aligned with the foreground so
       // the pinned status panel and a fresh restore never show a project that
       // belongs to a different (previously-foreground) session.
       sessionId: this.fg?.sessionId,
-      projectPath: this.fg?.cwd,
-      projectName: this.fg?.projectName,
+      projectPath: this.fixedCwd ?? this.fg?.cwd,
+      projectName: this.fixedProjectName ?? this.fg?.projectName,
     });
   }
 }

package/src/bot/commands.ts

@@ -1,31 +1,61 @@
 /**
  * Bot command definitions (for the Telegram command menu) and help text.
+ *
+ * Private chats get the full list (sorted by workflow). Groups/forum topics get
+ * 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 }[] = [
+  // Core control
   { command: "start", description: "Welcome, menu & status panel" },
-  { command: "menu", description: "Show the menu keyboard" },
-  { command: "projects", description: "Projects: list / search <q> / open <path> / new <name>" },
-  { command: "sessions", description: "List/resume sessions (active first) \u00b7 /sessions <q>" },
+  { command: "menu", description: "Open the menu" },
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn (alias of /cancel)" },
+  { command: "status", description: "Current session, project & queue" },
+  { command: "new", description: "New session in current project" },
+  // Sessions
+  { command: "running", description: "Sessions this chat controls" },
+  { command: "sessions", description: "List/resume sessions · /sessions <q>" },
   { command: "active", description: "Sessions running now on the PC" },
-  { command: "running", description: "Sessions this chat controls \u2014 switch between them" },
-  { command: "import", description: "Import a Kiro/OpenCode/Claude/Codex /running session" },
-  { command: "killall", description: "Kill all active sessions on the PC" },
-  { command: "mcp", description: "Inspect & toggle MCP servers \u00b7 health-check" },
-  { command: "tasks", description: "Manage scheduled tasks" },
-  { command: "newtask", description: "Create a scheduled task" },
   { command: "history", description: "Show recent conversation history" },
-  { command: "new", description: "Start a fresh session here" },
-  { command: "status", description: "Current session, project & queue" },
-  { command: "usage", description: "Account & context usage" },
-  { command: "btw", description: "Run ASAP (now if idle, else next): /btw <text>" },
+  { command: "import", description: "Import Kiro/OpenCode/Claude/Codex session" },
+  // Project
+  { command: "projects", description: "Projects: list / search / open / new" },
+  // Queue
+  { command: "btw", description: "Run ASAP: /btw <text>" },
   { command: "flush", description: "Send queued follow-ups now" },
   { command: "queue", description: "Show queued follow-ups" },
-  { command: "cancel", description: "Stop the current turn" },
-  { command: "unwatch", description: "Stop following a live session" },
+  // Account
+  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "reauth", description: "Sign in to Grok (login or import)" },
+  { command: "usage", description: "Account & context usage" },
+  // System / tools
+  { command: "mcp", description: "Inspect & toggle MCP servers" },
+  { command: "tasks", description: "Manage scheduled tasks" },
+  { command: "newtask", description: "Create a scheduled task" },
+  { 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: "reauth", description: "Sign in to Grok (login or import)" },
-  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "unwatch", description: "Stop following a live session" },
+  { command: "help", description: "Show help" },
+];
+
+/**
+ * Group / forum command menu — keep short; cancel & menu first so topics can
+ * stop a turn without the private reply-keyboard bar.
+ */
+export const GROUP_COMMANDS: { command: string; description: string }[] = [
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn" },
+  { command: "menu", description: "Open topic / group menu" },
+  { command: "status", description: "Session, project & queue" },
+  { command: "new", description: "New session in this topic/project" },
+  { command: "running", description: "Sessions this topic controls" },
+  { command: "sessions", description: "List / resume sessions" },
+  { command: "btw", description: "Queue or run: /btw <text>" },
+  { command: "flush", description: "Run queued follow-ups now" },
+  { command: "model", description: "Switch model: /model <id>" },
   { command: "help", description: "Show help" },
 ];
 
@@ -37,18 +67,28 @@ export const HELP_TEXT = [
   "\u2022 Just send a message to chat with Grok in the current project.",
   "\u2022 While Grok is working, anything you send is queued and runs",
   "  automatically when the current turn finishes.",
+  "\u2022 Persistent bar (private): \u2630 Menu \u00B7 \u{1F195} New session \u00B7 \u{1F9ED} Running \u00B7 \u23F9 Stop.",
+  "\u2022 New session: /new or the bar button (not the inline Menu message).",
+  "\u2022 In groups / forum topics: use /cancel or Menu \u2192 \u23F9 Stop",
+  "  (the persistent bar is unreliable in topics; use /new or topic menu).",
+  "",
+  "COMMANDS (core)",
+  "/menu \u2014 open the menu",
+  "/cancel or /stop \u2014 stop the current turn",
+  "/status \u2014 session, project and queue",
+  "/new \u2014 new session in the current project (also bar: \u{1F195} New session)",
+  "",
+  "COMMANDS (sessions)",
+  "/running \u2014 sessions this chat/topic controls",
+  "/sessions \u2014 resume a recent Grok session",
+  "/active \u2014 attach to a session running on the PC",
+  "/history \u2014 latest messages of the current session",
+  "/import \u2014 import a /running session from another agent",
   "",
-  "COMMANDS",
-  "/projects \u2014 choose which folder Grok works in",
-  "/sessions \u2014 resume one of your recent Grok sessions",
-  "/active \u2014 attach to a session currently running on the PC",
-  "/import \u2014 import a /running session from Kiro, OpenCode, Claude, or Codex",
-  "/history \u2014 show the latest messages of the current session",
-  "/new \u2014 start a brand-new session in the current project",
-  "/btw <text> \u2014 run it now if idle, otherwise right after the current task",
+  "COMMANDS (more)",
+  "/projects \u2014 choose which folder Grok works in (private chats)",
+  "/btw <text> \u2014 run now if idle, else right after the current task",
   "/flush \u2014 run queued follow-ups immediately",
-  "/cancel \u2014 stop the current turn",
-  "/status \u2014 show session, project and queue size",
-  "/reauth \u2014 sign in to Grok (grok login, or import an existing login)",
-  "/accounts \u2014 switch between saved Grok accounts",
+  "/reauth \u2014 sign in to Grok",
+  "/accounts \u2014 switch saved Grok accounts",
 ].join("\n");

package/src/bot/deps.ts

@@ -18,6 +18,7 @@ import type { TaskRunner } from "../tasks/runner.js";
 import type { TaskStore } from "../tasks/store.js";
 import type { StatusPanel } from "./menu/status-panel.js";
 import type { Ephemeral } from "./menu/ephemeral.js";
+import type { ForumManager } from "../forum/manager.js";
 import type { RuntimeRegistry } from "./registry.js";
 import type { TaskWizard } from "./wizard/task-wizard.js";
 
@@ -38,6 +39,8 @@ export interface BotDeps {
   stt: SttService;
   usage: UsageService;
   accounts: AccountManager;
+  /** Present when TOPIC_GROUP_ID is configured. */
+  forum?: ForumManager;
 }
 
 /** Caches the last project list shown per chat for callback resolution. */

package/src/bot/group-memory.ts

@@ -0,0 +1,159 @@
+/**
+ * Local "group memory" search across forum topics, session metadata, and
+ * recent session history. Telegram bots have no general message-search API,
+ * so this indexes what the bridge already stores on disk.
+ */
+import { join } from "node:path";
+import { readHistory } from "../sessions/history.js";
+import type { SessionMeta } from "../sessions/types.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { ForumTopicBinding } from "../forum/types.js";
+
+export type MemoryHitKind = "topic" | "session" | "history";
+
+export interface MemoryHit {
+  kind: MemoryHitKind;
+  title: string;
+  snippet: string;
+  score: number;
+  path?: string;
+  sessionId?: string;
+  threadId?: number;
+}
+
+export interface GroupMemorySearchOpts {
+  query: string;
+  limit?: number;
+  sessionsDir: string;
+  store: SessionStore;
+  topics?: ForumTopicBinding[];
+  /** Max sessions whose JSONL tails are scanned. */
+  maxSessions?: number;
+}
+
+/** Tokenize a query into lowercase alphanumeric tokens (min length 2). */
+export function tokenizeQuery(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9_./\\-]+/i)
+    .map((t) => t.trim())
+    .filter((t) => t.length >= 2)
+    .slice(0, 12);
+}
+
+/** Score how well `haystack` matches tokens (0 if no token hits). */
+export function scoreTokens(haystack: string, tokens: string[]): number {
+  if (!tokens.length || !haystack) return 0;
+  const h = haystack.toLowerCase();
+  let score = 0;
+  let hits = 0;
+  for (const t of tokens) {
+    if (!h.includes(t)) continue;
+    hits++;
+    // Prefer whole-word-ish hits slightly.
+    const re = new RegExp(`(?:^|[^a-z0-9])${escapeReg(t)}(?:[^a-z0-9]|$)`, "i");
+    score += re.test(h) ? 3 : 1;
+    // Density bonus for short fields.
+    if (h.length < 120) score += 1;
+  }
+  if (hits === 0) return 0;
+  // All-token bonus.
+  if (hits === tokens.length) score += 4;
+  return score;
+}
+
+/**
+ * Search topics + session store + recent history. Pure ranking over provided
+ * store; safe to call on the main bot thread (capped I/O).
+ */
+export function searchGroupMemory(opts: GroupMemorySearchOpts): MemoryHit[] {
+  const tokens = tokenizeQuery(opts.query);
+  if (tokens.length === 0) return [];
+  const limit = Math.max(1, Math.min(20, opts.limit ?? 8));
+  const maxSessions = opts.maxSessions ?? 40;
+  const hits: MemoryHit[] = [];
+
+  for (const t of opts.topics ?? []) {
+    const hay = [t.name, t.projectPath ?? "", t.kind, t.sessionId ?? ""].join("\n");
+    const score = scoreTokens(hay, tokens);
+    if (score <= 0) continue;
+    hits.push({
+      kind: "topic",
+      title: t.name,
+      snippet: t.projectPath ? `path: ${t.projectPath}` : `kind: ${t.kind}`,
+      score: score + 2, // slight boost for topic map
+      path: t.projectPath ?? undefined,
+      threadId: t.threadId,
+      sessionId: t.sessionId,
+    });
+  }
+
+  let metas: SessionMeta[] = [];
+  try {
+    metas = opts.store.list(maxSessions);
+  } catch {
+    metas = [];
+  }
+
+  for (const m of metas) {
+    const hay = [m.title, m.comment ?? "", m.cwd, m.sessionId].join("\n");
+    const score = scoreTokens(hay, tokens);
+    if (score > 0) {
+      hits.push({
+        kind: "session",
+        title: m.title || m.sessionId.slice(0, 8),
+        snippet: clamp(
+          [m.comment, m.cwd].filter(Boolean).join(" · ") || m.sessionId,
+          220,
+        ),
+        score,
+        path: m.cwd || undefined,
+        sessionId: m.sessionId,
+      });
+    }
+
+    // History tail (cheap): few entries, short text.
+    if (m.historyBytes <= 0) continue;
+    try {
+      const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
+      const entries = readHistory(path, 12);
+      for (const e of entries) {
+        if (!e.text?.trim()) continue;
+        const s = scoreTokens(e.text, tokens);
+        if (s <= 0) continue;
+        hits.push({
+          kind: "history",
+          title: `${e.role} · ${(m.title || m.sessionId.slice(0, 8)).slice(0, 40)}`,
+          snippet: clamp(e.text.replace(/\s+/g, " ").trim(), 220),
+          score: s,
+          path: m.cwd || undefined,
+          sessionId: m.sessionId,
+        });
+      }
+    } catch {
+      /* ignore unreadable logs */
+    }
+  }
+
+  hits.sort((a, b) => b.score - a.score || a.kind.localeCompare(b.kind));
+  // Dedupe near-identical snippets.
+  const seen = new Set<string>();
+  const out: MemoryHit[] = [];
+  for (const h of hits) {
+    const key = `${h.kind}|${h.sessionId ?? h.threadId ?? ""}|${h.snippet.slice(0, 80)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(h);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function clamp(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+
+function escapeReg(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/bot/handlers/accounts.ts

@@ -294,6 +294,13 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
         await deps.acp.start(true).catch(() => {});
         throw e;
       }
+      // Remember preferred account for this chat/topic scope (model/reasoning peers).
+      try {
+        const { resolveScope } = await import("../scope.js");
+        resolveScope(ctx, deps).rt.setPreferredAccountId(id);
+      } catch {
+        /* non-fatal */
+      }
       const note = (await deps.usage.isLoggedIn())
         ? `\u2705 Now signed in as ${meta.label}. Your next message runs on this account.`
         : `\u26A0\uFE0F Switched to ${meta.label}, but no usable login is active. ${UNSUPPORTED_LOGIN_HELP}`;

package/src/bot/handlers/control.ts

@@ -1,28 +1,41 @@
 /**
- * Control commands: /start /help /status /new /cancel /btw /flush.
+ * Control commands: /start /help /status /new /cancel /stop /btw /flush /menu.
+ *
+ * Slash messages are deleted instantly by bot.ts middleware; handlers post
+ * bot status messages so the user always sees the bot is alive (CLI can be slow).
  */
-import type { Bot } from "grammy";
+import type { Bot, Context } from "grammy";
 import { basename } from "node:path";
 import { textPrompt } from "../../app/types.js";
 import type { BotDeps } from "../deps.js";
 import { HELP_TEXT } from "../commands.js";
 import { compactKeyboard } from "../menu/keyboard.js";
 import { refreshMenu } from "../menu/refresh.js";
+import { adoptUserPrompt } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
+import { resolveScope } from "../scope.js";
 import { openMainMenu } from "./menu.js";
 
 export function registerControl(bot: Bot, deps: BotDeps): void {
   bot.command("start", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
     const agent = deps.acp.agentInfo;
+    const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
     const lines = [
       "\u{1F44B} Welcome! I bridge Telegram to Grok Build over ACP.",
       agent?.name ? `Connected to ${agent.name} ${agent.version ?? ""}`.trim() : "",
       "",
-      "Tap \u2630 Menu for everything. A live status panel appears while I work",
-      "(\u2630 Menu \u2192 Status shows it anytime). Just send a message to start.",
+      isGroup || scope.isForum
+        ? "In groups / topics: /menu for controls, /cancel or /stop to halt a turn."
+        : "Bar: \u2630 Menu \u00B7 \u{1F195} New session \u00B7 \u{1F9ED} Running \u00B7 \u23F9 Stop. Live status panel while I work",
+      isGroup || scope.isForum
+        ? "Just send a message in this topic to start."
+        : "(\u2630 Menu \u2192 Status shows it anytime). Just send a message to start.",
     ].filter(Boolean);
-    await ctx.reply(lines.join("\n"), { reply_markup: compactKeyboard() });
+    await ctx.reply(lines.join("\n"), {
+      reply_markup: compactKeyboard(),
+      ...scope.threadExtra,
+    });
     await deps.statusPanel.refresh(ctx.chat.id);
   });
 
@@ -32,71 +45,111 @@ export function registerControl(bot: Bot, deps: BotDeps): void {
   });
 
   bot.command("help", async (ctx) => {
-    await ctx.reply(HELP_TEXT);
+    const scope = resolveScope(ctx, deps);
+    await ctx.reply(HELP_TEXT, scope.threadExtra);
   });
 
   bot.command("status", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
     const lines = [
       "\u{1F4CA} Status",
+      scope.isForum ? `Topic: ${scope.projectName ?? "topic"}` : "",
       `Project: ${rt.projectName ?? (basename(rt.cwd) || rt.cwd)}`,
       `Folder: ${rt.cwd}`,
       `Session: ${rt.sessionId ?? "(none yet)"}`,
+      `Model: ${rt.model || "default"}`,
+      `Reasoning: ${rt.reasoning}`,
       `State: ${rt.isBusy ? "\u23F3 working" : "\u2705 idle"}`,
       `Queued follow-ups: ${rt.queueLength}`,
-    ];
+    ].filter(Boolean);
     const subagents = deps.registry.subagentSummaryForChat(ctx.chat.id);
     if (subagents) lines.push(`Subagents: ${subagents}`);
-    await ctx.reply(lines.join("\n"));
+    await ctx.reply(lines.join("\n"), scope.threadExtra);
   });
 
   bot.command("new", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    // Instant feedback before ACP session/new (can be slow on cold CLI).
+    // Same copy as bar 🆕 New and inline m:new.
+    await ctx.reply("\u2728 Creating new session\u2026", scope.threadExtra).catch(() => {});
     try {
-      await deps.registry.controller(ctx.chat.id).addNew(rt.cwd, rt.projectName);
-      await refreshMenu(ctx, deps, `\u2728 New session started in ${rt.projectName ?? rt.cwd}`);
+      await scope.controller.addNew(scope.rt.cwd, scope.rt.projectName);
+      await refreshMenu(ctx, deps, `\u2728 New session in ${scope.rt.projectName ?? scope.rt.cwd}`);
     } catch (err) {
-      await ctx.reply(`\u274C Could not start session: ${(err as Error).message}`);
+      await ctx.reply(`\u274C ${(err as Error).message}`, scope.threadExtra);
     }
   });
 
-  bot.command("cancel", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
-    const cancelled = await rt.cancel();
-    await ctx.reply(cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.");
-  });
+  const cancelTurn = async (ctx: Context): Promise<void> => {
+    const scope = resolveScope(ctx, deps);
+    const cancelled = await scope.rt.cancel();
+    await ctx.reply(
+      cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.",
+      scope.threadExtra,
+    );
+  };
+
+  bot.command("cancel", cancelTurn);
+  bot.command("stop", cancelTurn);
 
   bot.command("btw", async (ctx) => {
     const text = (ctx.match || "").toString().trim();
     if (!text) {
-      await ctx.reply("Usage: /btw <something for the agent to do — now if idle, otherwise next>");
+      const scope = resolveScope(ctx, deps);
+      await ctx.reply(
+        "Usage: /btw <something for the agent to do — now if idle, otherwise next>",
+        scope.threadExtra,
+      );
       return;
     }
-    const rt = deps.registry.get(ctx.chat.id);
-    // Run it right away when idle; otherwise queue it to run automatically the
-    // moment the current turn finishes (can't interrupt an in-flight agent turn).
-    const outcome = await rt.submit(textPrompt(text, undefined, extractReplyContext(ctx)));
+    const scope = resolveScope(ctx, deps);
+    const userMsgId = ctx.message?.message_id;
+    const anchor = await adoptUserPrompt(deps.api, {
+      chatId: ctx.chat.id,
+      text,
+      // Command middleware already deleted the slash message; re-delete is a no-op.
+      userMessageIds: userMsgId !== undefined ? [userMsgId] : [],
+      messageThreadId: scope.threadExtra.message_thread_id,
+      projectName: scope.rt.projectName,
+      prefix: "\u{1F4DD} /btw",
+    });
+    // Fall back to userMsgId if anchor send failed (message may already be gone).
+    const outcome = await scope.rt.submit(
+      textPrompt(text, anchor?.replyTo ?? userMsgId, extractReplyContext(ctx), {
+        promptId: anchor?.promptId,
+      }),
+    );
     if (outcome === "queued") {
+      const extra: Record<string, unknown> = { ...scope.threadExtra };
+      if (anchor?.replyTo !== undefined) {
+        extra.reply_parameters = {
+          message_id: anchor.replyTo,
+          allow_sending_without_reply: true,
+        };
+      }
       await ctx.reply(
-        `\u{1F4E5} Queued (position ${rt.queueLength}) \u2014 it'll run automatically as soon as the current task finishes.`,
+        `\u{1F4E5} Queued (position ${scope.rt.queueLength}) \u2014 it'll run automatically as soon as the current task finishes.`,
+        extra,
       );
-    } else {
-      await ctx.reply("\u25B6\uFE0F On it\u2026");
     }
   });
 
   bot.command("flush", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
     if (rt.queueLength === 0) {
-      await ctx.reply("Queue is empty.");
+      await ctx.reply("Queue is empty.", scope.threadExtra);
       return;
     }
     if (rt.isBusy) {
-      await ctx.reply(`\u23F3 ${rt.queueLength} queued \u2014 they'll run automatically when the current turn ends.`);
+      await ctx.reply(
+        `\u23F3 ${rt.queueLength} queued \u2014 they'll run automatically when the current turn ends.`,
+        scope.threadExtra,
+      );
       return;
     }
-    // Idle: drain the queue by submitting an empty trigger that flushes.
-    await ctx.reply("\u25B6\uFE0F Running queued follow-ups\u2026");
+    await ctx.reply("\u25B6\uFE0F Running queued follow-ups\u2026", scope.threadExtra);
     const drained = rt.drainQueueToPrompt();
     if (drained) await rt.submit(drained);
   });