grok-telegram-bot 2.4.0 → 2.6.0

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);
   });

package/src/bot/handlers/document.ts

@@ -57,7 +57,7 @@ export function registerDocuments(bot: Bot, deps: BotDeps): void {
 
     const caption = ctx.message.caption ?? "";
     const quoted = extractReplyContext(ctx);
-    const replyTo = ctx.message.message_id;
+    const userMsgId = ctx.message.message_id;
 
     let promptText: string;
     if (looksLikeText(buf, doc.mime_type, name)) {
@@ -75,10 +75,37 @@ export function registerDocuments(bot: Bot, deps: BotDeps): void {
     }
 
     try {
-      const rt = deps.registry.get(chatId);
-      const outcome = await rt.submit(textPrompt(promptText, replyTo, quoted));
+      const { resolveScope } = await import("../scope.js");
+      const { adoptUserPrompt } = await import("../prompt-anchor.js");
+      const scope = resolveScope(ctx, deps);
+      const anchorPreview = caption.trim() || `File: ${name}`;
+      const anchor = await adoptUserPrompt(deps.api, {
+        chatId,
+        text: anchorPreview,
+        userMessageIds: [userMsgId],
+        messageThreadId: scope.threadExtra.message_thread_id,
+        projectName: scope.rt.projectName,
+        prefix: `\u{1F4CE} ${name}`,
+        // Re-post the file so it stays in chat after the user message is deleted.
+        media: [{ type: "document", fileId: doc.file_id, fileName: name }],
+      });
+      const outcome = await scope.rt.submit(
+        textPrompt(promptText, anchor?.replyTo ?? userMsgId, quoted, {
+          promptId: anchor?.promptId,
+        }),
+      );
       if (outcome === "queued") {
-        await ctx.reply(`\u{1F4E5} Queued "${name}" \u2014 will run after the current task.`);
+        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 "${name}" \u2014 will run after the current task.`,
+          extra,
+        );
       }
     } catch (e) {
       log.warn(`submit failed for "${name}":`, (e as Error).message);

package/src/bot/handlers/forum.ts

@@ -0,0 +1,217 @@
+/**
+ * Forum topic group: auto-setup, user-created topic binding, and path prompts.
+ */
+import type { Bot } from "grammy";
+import { createLogger } from "../../logger.js";
+import type { ForumManager } from "../../forum/manager.js";
+import type { BotDeps } from "../deps.js";
+import {
+  FORUM_GENERAL_THREAD_ID,
+  forumThreadId,
+  outboundThreadExtra,
+} from "../../forum/thread.js";
+
+const log = createLogger("forum-handler");
+
+const BIND_HINT =
+  `Send the **absolute project path** or an **exact** catalog project name to bind this topic.\n` +
+  `Example: \`H:\\\\Lucru\\\\Domains\\\\MyApp\``;
+
+export function registerForum(bot: Bot, deps: BotDeps, forum: ForumManager): void {
+  const groupId = forum.groupId;
+
+  // Service message: user (or another admin) created a topic.
+  bot.on("message:forum_topic_created", async (ctx) => {
+    if (ctx.chat?.id !== groupId) return;
+    // Group ignored (not admin / no Topics / probe failed).
+    if (!forum.isReady) {
+      log.debug(`ignore forum_topic_created — forum not ready (${forum.getStatusText()})`);
+      return;
+    }
+    const created = ctx.message.forum_topic_created;
+    const threadId = ctx.message.message_thread_id;
+    if (!created || threadId === undefined) return;
+    // Skip General — always workspace-bound.
+    if (threadId === FORUM_GENERAL_THREAD_ID) return;
+
+    forum.noteUserTopic(threadId, created.name);
+    log.info(`user topic created: ${created.name} (#${threadId})`);
+
+    // Exact catalog name → bind immediately (no message required).
+    const auto = await forum.tryAutoBindByTopicName(threadId, created.name);
+    if (auto.status === "bound") {
+      await ctx
+        .reply(
+          `\u2705 Topic **${created.name}** auto-bound to project:\n\`${auto.binding.projectPath}\`\n\nYou can chat here now.`,
+          { parse_mode: "Markdown", message_thread_id: threadId },
+        )
+        .catch(() => {});
+      return;
+    }
+
+    if (auto.status === "already_bound") {
+      await ctx
+        .reply(
+          `\u{1F4CC} New topic **${created.name}**.\n\n` +
+            `Exact catalog match \`${auto.projectPath}\` is already bound to topic #${auto.otherThreadId}.\n` +
+            BIND_HINT,
+          { parse_mode: "Markdown", message_thread_id: threadId },
+        )
+        .catch(() => {});
+      return;
+    }
+
+    await ctx
+      .reply(
+        `\u{1F4CC} New topic **${created.name}**.\n\n` +
+          `No exact catalog project matched this name.\n` +
+          BIND_HINT,
+        { parse_mode: "Markdown", message_thread_id: threadId },
+      )
+      .catch(() => {});
+  });
+
+  // Re-probe when the bot is promoted/demoted in the configured group.
+  bot.on("my_chat_member", async (ctx) => {
+    if (ctx.chat?.id !== groupId) return;
+    const status = ctx.myChatMember.new_chat_member.status;
+    if (status === "administrator" || status === "creator") {
+      log.info(`bot became ${status} in topic group — re-running forum setup`);
+      void forum.ensureSetup().catch((e) => {
+        log.warn(`forum re-setup after promotion failed: ${(e as Error).message}`);
+      });
+      return;
+    }
+    if (status === "member" || status === "restricted" || status === "left" || status === "kicked") {
+      forum.markDisabled(
+        "not_admin",
+        `bot status is now "${status}" — forum topic management ignored until the bot is admin again`,
+      );
+    }
+  });
+
+  // Optional: re-run setup command for admins in the group.
+  bot.command("forum_setup", async (ctx) => {
+    const threadId = ctx.message?.message_thread_id;
+    const replyOpts = outboundThreadExtra(threadId);
+    if (ctx.chat?.id !== groupId) {
+      await ctx.reply("Use this command inside the configured forum group.", replyOpts).catch(() => {});
+      return;
+    }
+    await ctx
+      .reply(
+        "Setting up forum topics (this can take a while for large catalogs)…",
+        replyOpts,
+      )
+      .catch(() => {});
+    try {
+      await forum.ensureSetup();
+      if (!forum.isReady) {
+        await ctx
+          .reply(
+            `\u26A0\uFE0F Forum setup skipped / group ignored.\n${forum.getStatusText()}`,
+            replyOpts,
+          )
+          .catch(() => {});
+        return;
+      }
+      const n = forum.store.all().length;
+      await ctx
+        .reply(`\u2705 Forum setup done. ${n} topic(s) mapped.\n${forum.getStatusText()}`, replyOpts)
+        .catch(() => {});
+    } catch (e) {
+      await ctx.reply(`Setup failed: ${(e as Error).message}`, replyOpts).catch(() => {});
+    }
+  });
+
+  void deps;
+}
+
+/**
+ * Resolve a forum-group text message to a SessionRuntime, or handle bind flow.
+ * Returns "handled" when the message was consumed (bind ask / bind result).
+ */
+export async function resolveForumRuntime(
+  deps: BotDeps,
+  forum: ForumManager,
+  chatId: number,
+  threadId: number | undefined,
+  text: string,
+  messageId: number,
+): Promise<{ rt: import("../session-runtime.js").SessionRuntime } | "handled" | "ignore"> {
+  if (chatId !== forum.groupId) return "ignore";
+  // Not admin / Topics off / probe failed — do not steal group messages.
+  if (!forum.isReady) return "ignore";
+  const tid = forumThreadId(threadId);
+
+  // General topic → always workspace (no path prompt).
+  if (tid === FORUM_GENERAL_THREAD_ID) {
+    const cwd = deps.cfg.workspace;
+    if (!forum.store.get(tid)?.projectPath) {
+      forum.store.bindProject(tid, cwd, "General", "general");
+    }
+    const rt = deps.registry.getForumTopic(chatId, tid, cwd, "General");
+    return { rt };
+  }
+
+  // Ensure we know about this thread.
+  let binding = forum.store.get(tid);
+  if (!binding) {
+    binding = forum.noteUserTopic(tid, `Topic ${tid}`);
+  }
+
+  // Unbound only: try to interpret text as path / exact catalog name (do not
+  // steal normal prompts when already bound — even if pending flag is stale).
+  if (!binding.projectPath) {
+    const result = forum.tryBindPath(tid, text);
+    if (result.ok) {
+      const iconNote = result.binding.iconPath ? `\nIcon: ${result.binding.iconPath}` : "";
+      await deps.api
+        .sendMessage(
+          chatId,
+          `\u2705 Bound to project:\n\`${result.binding.projectPath}\`${iconNote}\n\nYou can chat here now.`,
+          {
+            ...outboundThreadExtra(tid),
+            parse_mode: "Markdown",
+            reply_parameters: { message_id: messageId },
+          },
+        )
+        .catch(() => {});
+      // Warm runtime; path-only message is not submitted as an agent prompt.
+      const resolved = forum.resolveCwd(tid);
+      if (resolved) {
+        deps.registry.getForumTopic(chatId, tid, resolved.cwd, resolved.projectName);
+      }
+      return "handled";
+    }
+    await deps.api
+      .sendMessage(
+        chatId,
+        `\u2753 ${result.error}\n\n${BIND_HINT.replace(/\*\*/g, "")}`,
+        {
+          ...outboundThreadExtra(tid),
+          reply_parameters: { message_id: messageId },
+        },
+      )
+      .catch(() => {});
+    return "handled";
+  }
+
+  const resolved = forum.resolveCwd(tid);
+  if (!resolved) {
+    forum.store.markPending(tid);
+    await deps.api
+      .sendMessage(
+        chatId,
+        `\u2753 This topic is not linked to a project yet.\n${BIND_HINT.replace(/\*\*/g, "")}`,
+        outboundThreadExtra(tid),
+      )
+      .catch(() => {});
+    return "handled";
+  }
+
+  // Multi-session controller for this topic (own model/reasoning/running list).
+  // First message with no sessionId creates one via ensureSession on submit.
+  const controller = deps.registry.forumController(chatId, tid, resolved.cwd, resolved.projectName);
+  return { rt: controller.foreground() };
+}

package/src/bot/handlers/menu.ts

@@ -11,8 +11,17 @@ import { type Bot, type Context, InlineKeyboard } from "grammy";
 import { reasoningLabel } from "../../app/reasoning.js";
 import { REASONING_LEVELS, type ReasoningEffort } from "../../app/types.js";
 import type { BotDeps } from "../deps.js";
-import { BAR_LABELS, compactKeyboard, mainMenuInline, MENU_BTN, RUNNING_BTN, STOP_BTN } from "../menu/keyboard.js";
+import {
+  BAR_LABELS,
+  compactKeyboard,
+  mainMenuInline,
+  MENU_BTN,
+  NEW_BTN,
+  RUNNING_BTN,
+  STOP_BTN,
+} from "../menu/keyboard.js";
 import { refreshMenu } from "../menu/refresh.js";
+import { resolveScope } from "../scope.js";
 import { showImportSources } from "./import-session.js";
 import { showKillConfirm } from "./kill.js";
 import { showMcp } from "./mcp.js";
@@ -23,14 +32,25 @@ import { showSessions } from "./sessions.js";
 import { showTasks } from "./tasks.js";
 import { showUsage } from "./usage.js";
 
-/** Open the full inline menu, showing the current model/reasoning. */
+/** Open the full inline menu, showing the current model/reasoning (topic-aware). */
 export async function openMainMenu(ctx: Context, deps: BotDeps): Promise<void> {
   await deps.ephemeral.open(ctx);
-  const rt = deps.registry.get(ctx.chat!.id);
-  await deps.ephemeral.reply(ctx, "\u2699\uFE0F Menu", {
+  const scope = resolveScope(ctx, deps);
+  const preferred = scope.rt.preferredAccountId;
+  const saved = preferred
+    ? deps.accounts.list().find((a) => a.id === preferred || a.loginId === preferred)
+    : undefined;
+  const accountLabel = saved?.label || preferred?.slice(0, 12) || undefined;
+  const title = scope.isForum
+    ? `\u2699\uFE0F Topic menu \u00B7 ${scope.projectName ?? "topic"}`
+    : "\u2699\uFE0F Menu";
+  await deps.ephemeral.reply(ctx, title, {
     reply_markup: mainMenuInline({
-      model: rt.model || "default",
-      reasoning: reasoningLabel(rt.reasoning),
+      model: scope.rt.model || "default",
+      reasoning: reasoningLabel(scope.rt.reasoning),
+      forumTopic: scope.isForum
+        ? { name: scope.projectName ?? "Topic", account: accountLabel }
+        : undefined,
     }),
   });
 }
@@ -39,14 +59,27 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
   // Compact persistent bar.
   bot.hears(BAR_LABELS, async (ctx) => {
     deps.wizard.abort(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
     switch (ctx.message?.text) {
       case MENU_BTN:
         return openMainMenu(ctx, deps);
+      case NEW_BTN: {
+        await ctx.reply("\u2728 Creating new session\u2026", scope.threadExtra).catch(() => {});
+        try {
+          await scope.controller.addNew(scope.rt.cwd, scope.rt.projectName);
+          return refreshMenu(ctx, deps, `\u2728 New session in ${scope.rt.projectName ?? scope.rt.cwd}`);
+        } catch (e) {
+          return void ctx.reply(`\u274C ${(e as Error).message}`, scope.threadExtra);
+        }
+      }
       case RUNNING_BTN:
         return showRunning(ctx, deps);
       case STOP_BTN: {
-        const rt = deps.registry.get(ctx.chat.id);
-        return void ctx.reply((await rt.cancel()) ? "\u23F9 Cancelling\u2026" : "Nothing is running.");
+        const cancelled = await scope.rt.cancel();
+        return void ctx.reply(
+          cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.",
+          scope.threadExtra,
+        );
       }
     }
   });
@@ -57,7 +90,7 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
   // ── Reasoning ──────────────────────────────────────────────────────────────
   bot.callbackQuery(/^reason:(minimal|low|medium|high|max)$/, async (ctx) => {
     const level = ctx.match![1] as ReasoningEffort;
-    deps.registry.get(ctx.chat!.id).setReasoningPref(level);
+    resolveScope(ctx, deps).rt.setReasoningPref(level);
     await confirm(ctx, deps, `\u{1F9E0} Reasoning: ${reasoningLabel(level)}`);
   });
 
@@ -66,37 +99,52 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
     const entry = deps.acp.availableModels[Number(ctx.match![1])];
     if (!entry) return void ctx.answerCallbackQuery({ text: "Expired, tap Model again." });
     await ctx.answerCallbackQuery({ text: `\u{1F9E9} Model: ${entry.name}` });
-    const res = await deps.registry.get(ctx.chat!.id).setModelPref(entry.modelId);
+    const res = await resolveScope(ctx, deps).rt.setModelPref(entry.modelId);
     if (!res.ok) {
-      await ctx.reply(`\u26A0\uFE0F Model set failed: ${res.error}`).catch(() => {});
+      await ctx.reply(`\u26A0\uFE0F Model set failed: ${res.error}`, resolveScope(ctx, deps).threadExtra).catch(() => {});
     }
     await confirmUi(ctx, deps);
   });
   bot.callbackQuery("model:clear", async (ctx) => {
     await ctx.answerCallbackQuery({ text: "\u{1F9E9} Model: default" });
-    await deps.registry.get(ctx.chat!.id).setModelPref("");
+    await resolveScope(ctx, deps).rt.setModelPref("");
     await confirmUi(ctx, deps);
   });
 }
 
 /** Dispatch an inline-menu action (`m:<action>`). */
 async function dispatchMenu(ctx: Context, deps: BotDeps, action: string): Promise<void> {
-  const chatId = ctx.chat!.id;
-  const rt = deps.registry.get(chatId);
+  const scope = resolveScope(ctx, deps);
+  const { chatId, rt, controller, threadExtra, isForum, projectName, projectPath } = scope;
   switch (action) {
     case "close":
       await ctx.answerCallbackQuery();
       return void ctx.deleteMessage().catch(() => {});
+    case "topicinfo":
+      await ctx.answerCallbackQuery();
+      return void deps.ephemeral.reply(
+        ctx,
+        `\u{1F4C1} **Topic project**\n${projectName ?? "?"}\n\`${projectPath ?? rt.cwd}\`\n\n` +
+          `Model / reasoning / running sessions on this menu are for **this topic only**.`,
+      );
     case "hidebar":
       await ctx.answerCallbackQuery();
       await ctx.deleteMessage().catch(() => {});
       return void ctx.reply("\u{1F648} Bar hidden \u2014 send /menu to bring it back.", {
         reply_markup: { remove_keyboard: true },
+        ...threadExtra,
       });
     case "showbar":
       await ctx.answerCallbackQuery();
-      return void ctx.reply("\u2328\uFE0F Bar restored.", { reply_markup: compactKeyboard() });
+      return void ctx.reply("\u2328\uFE0F Bar restored.", {
+        reply_markup: compactKeyboard(),
+        ...threadExtra,
+      });
     case "project":
+      if (isForum) {
+        await ctx.answerCallbackQuery({ text: "Project is fixed to this topic", show_alert: true });
+        return;
+      }
       await ctx.answerCallbackQuery();
       return showProjects(ctx, deps);
     case "running":
@@ -142,17 +190,26 @@ async function dispatchMenu(ctx: Context, deps: BotDeps, action: string): Promis
       await ctx.answerCallbackQuery();
       return showKillConfirm(ctx, deps);
     case "new":
-      await ctx.answerCallbackQuery();
+      await ctx.answerCallbackQuery({ text: "Creating session\u2026" });
+      await ctx.reply("\u2728 Creating new session\u2026", threadExtra).catch(() => {});
       try {
-        await deps.registry.controller(chatId).addNew(rt.cwd, rt.projectName);
+        await controller.addNew(rt.cwd, rt.projectName);
         return refreshMenu(ctx, deps, `\u2728 New session in ${rt.projectName ?? rt.cwd}`);
       } catch (e) {
-        return void ctx.reply(`\u274C ${(e as Error).message}`);
+        return void ctx.reply(`\u274C ${(e as Error).message}`, threadExtra);
       }
     case "stop": {
       // Answer first so a slow cancel never times out the callback query.
-      await ctx.answerCallbackQuery({ text: rt.isBusy ? "Cancelling\u2026" : "Nothing is running" });
-      if (rt.isBusy) await rt.cancel();
+      const busy = rt.isBusy;
+      await ctx.answerCallbackQuery({ text: busy ? "Cancelling\u2026" : "Nothing is running" });
+      const cancelled = busy ? await rt.cancel() : false;
+      // Visible in-topic feedback (callback toasts are easy to miss in groups).
+      await ctx
+        .reply(
+          cancelled || busy ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.",
+          threadExtra,
+        )
+        .catch(() => {});
       return;
     }
     default:
@@ -178,20 +235,25 @@ async function confirmUi(ctx: Context, deps: BotDeps): Promise<void> {
 }
 
 async function showReasoningMenu(ctx: Context, deps: BotDeps): Promise<void> {
-  const rt = deps.registry.get(ctx.chat!.id);
+  const rt = resolveScope(ctx, deps).rt;
   await deps.ephemeral.open(ctx);
   const kb = new InlineKeyboard();
   REASONING_LEVELS.forEach((l) => kb.text(`${l === rt.reasoning ? "\u2713 " : ""}${reasoningLabel(l)}`, `reason:${l}`));
-  await deps.ephemeral.reply(ctx, `Current reasoning: ${reasoningLabel(rt.reasoning)}\nChoose effort:`, { reply_markup: kb });
+  await deps.ephemeral.reply(ctx, `Current reasoning: ${reasoningLabel(rt.reasoning)}\nChoose effort:`, {
+    reply_markup: kb,
+  });
 }
 
 async function showModelMenu(ctx: Context, deps: BotDeps): Promise<void> {
-  const rt = deps.registry.get(ctx.chat!.id);
+  const rt = resolveScope(ctx, deps).rt;
   await ensureReady(ctx, rt);
   await deps.ephemeral.open(ctx);
   const models = deps.acp.availableModels;
   if (models.length === 0) {
-    await deps.ephemeral.reply(ctx, "No selectable models reported by Grok yet \u2014 send a message first, then try again.");
+    await deps.ephemeral.reply(
+      ctx,
+      "No selectable models reported by Grok yet \u2014 send a message first, then try again.",
+    );
     return;
   }
   const current = rt.model || deps.acp.currentModelId;