grok-telegram-bot 2.4.0 → 2.5.0

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,207 @@
+/**
+ * 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 } 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 =
+      threadId !== undefined ? { message_thread_id: 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.`,
+          { message_thread_id: 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, "")}`,
+        { message_thread_id: 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, "")}`,
+        { message_thread_id: 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;

package/src/bot/handlers/message.ts

@@ -8,6 +8,10 @@
  * rapid consecutive text messages per chat within a short debounce window
  * (`MESSAGE_BATCH_MS`) into a single prompt — one submission, one confirmation.
  *
+ * User messages are replaced by a bot-owned prompt anchor (`#prompt_<id>`) so
+ * the chat shows immediate life while CLI/ACP starts, and all AI replies thread
+ * to that anchor with the same searchable tag.
+ *
  * While a turn is running, the combined message is queued and runs
  * automatically when the current turn finishes.
  * (Wizard input and menu-button text are intercepted by earlier handlers.)
@@ -15,89 +19,165 @@
 import type { Bot } from "grammy";
 import { textPrompt } from "../../app/types.js";
 import { createLogger } from "../../logger.js";
+import { batchKey, forumThreadId } from "../../forum/thread.js";
 import type { BotDeps } from "../deps.js";
+import { adoptUserPrompt } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
+import { resolveForumRuntime } from "./forum.js";
 
 const log = createLogger("message");
 
-/** A pending burst of text messages from one chat, awaiting coalescing. */
+/** A pending burst of text messages from one chat/topic, awaiting coalescing. */
 interface TextBatch {
   parts: string[];
   ids: number[];
+  /** Forum topic thread id (undefined for private chats / General without id). */
+  threadId?: number;
   /** Reference content if the burst began as a reply to another message. */
   quoted?: string;
   timer: NodeJS.Timeout;
 }
 
 export function registerMessages(bot: Bot, deps: BotDeps): void {
-  const batches = new Map<number, TextBatch>();
+  const batches = new Map<string, TextBatch>();
   const windowMs = deps.cfg.messageBatchMs;
 
-  const arm = (chatId: number): NodeJS.Timeout =>
-    setTimeout(() => void flush(deps, batches, chatId), windowMs);
+  const arm = (key: string): NodeJS.Timeout =>
+    setTimeout(() => void flush(deps, batches, key), windowMs);
 
   bot.on("message:text", async (ctx) => {
     const text = ctx.message.text;
     if (!text.trim()) return;
+    // Slash commands are handled by bot.command / menu — never batch as agent prompts.
+    // (Otherwise /forum_setup and /help would also hit the debounce → agent path.)
+    if (!text.includes("\n") && text.startsWith("/")) return;
+
     const chatId = ctx.chat.id;
     const id = ctx.message.message_id;
+    const rawThreadId = ctx.message.message_thread_id;
+    const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+    const threadId = isForum ? forumThreadId(rawThreadId) : rawThreadId;
     const quoted = extractReplyContext(ctx);
+    const key = batchKey(chatId, rawThreadId, isForum);
 
-    const batch = batches.get(chatId);
+    const batch = batches.get(key);
     if (batch) {
       clearTimeout(batch.timer);
       batch.parts.push(text);
       batch.ids.push(id);
       if (quoted && !batch.quoted) batch.quoted = quoted;
-      batch.timer = arm(chatId);
+      batch.timer = arm(key);
       return;
     }
-    batches.set(chatId, { parts: [text], ids: [id], quoted, timer: arm(chatId) });
+    batches.set(key, {
+      parts: [text],
+      ids: [id],
+      threadId,
+      quoted,
+      timer: arm(key),
+    });
   });
 }
 
 /** Coalesce a chat's buffered parts into one prompt and submit it once. */
-async function flush(deps: BotDeps, batches: Map<number, TextBatch>, chatId: number): Promise<void> {
-  const batch = batches.get(chatId);
+async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string): Promise<void> {
+  const batch = batches.get(key);
   if (!batch) return;
-  batches.delete(chatId);
+  batches.delete(key);
 
   // Telegram splits at 4096 chars, almost always on a line boundary, so
   // rejoining with a newline reconstructs the original text faithfully.
   const combined = batch.parts.join("\n").trim();
   if (!combined) return;
 
-  // A lone, single-line "/something" is an unknown-command typo — guide the
-  // user instead of forwarding it to the agent. Split content never trips
-  // this: it arrives as multiple parts, and multi-line text is never a command.
+  const [chatIdStr] = key.split(":");
+  const chatId = Number(chatIdStr);
+  const threadId = batch.threadId;
+
+  // Defense-in-depth: never submit slash-only lines as agent prompts.
   if (batch.parts.length === 1 && !combined.includes("\n") && combined.startsWith("/")) {
-    await send(deps, chatId, "Unknown command. Type /help to see what I can do.");
     return;
   }
 
-  const rt = deps.registry.get(chatId);
+  let rt = deps.registry.get(chatId);
+  // Forum group: topic-scoped multi-session controller (model/reasoning/running).
+  if (deps.forum?.isActiveForumChat(chatId)) {
+    const resolved = await resolveForumRuntime(
+      deps,
+      deps.forum,
+      chatId,
+      threadId,
+      combined,
+      batch.ids[0]!,
+    );
+    if (resolved === "handled" || resolved === "ignore") return;
+    rt = resolved.rt;
+    // If nothing is selected / no session yet, ensure a new session is created
+    // on first message (ensureSession inside submit). If FG has no sessionId
+    // after a closed session, start a fresh one for this topic.
+    if (!rt.sessionId && !rt.isBusy) {
+      try {
+        await rt.startNewSession(rt.cwd, rt.projectName);
+      } catch {
+        /* ensureSession on submit will retry */
+      }
+    }
+  }
+
   const note = batch.parts.length > 1 ? ` (combined ${batch.parts.length} messages)` : "";
+  // Hoisted so a submit failure after a successful adopt can still thread the error.
+  let replyTo: number | undefined = batch.ids[0];
   try {
-    // Thread the reply to the prompt message (the user's message is left intact;
-    // the agent's response + Done reply to it, and carry searchable hashtags).
-    const outcome = await rt.submit(textPrompt(combined, batch.ids[0], batch.quoted));
+    // Instant bot anchor: user sees the prompt adopted immediately while CLI warms.
+    // All AI output + Done reply to this message and carry #prompt_<id>.
+    const anchor = await adoptUserPrompt(deps.api, {
+      chatId,
+      text: combined,
+      userMessageIds: batch.ids,
+      messageThreadId: threadId,
+      projectName: rt.projectName,
+      prefix: "\u{1F4DD} Prompt",
+    });
+    replyTo = anchor?.replyTo ?? batch.ids[0];
+    const outcome = await rt.submit(
+      textPrompt(combined, replyTo, batch.quoted, { promptId: anchor?.promptId }),
+    );
     if (outcome === "queued") {
       await send(
         deps,
         chatId,
         `\u{1F4E5} Queued (position ${rt.queueLength})${note} \u2014 I'm still working on the previous task. It'll run next.`,
+        threadId,
+        replyTo,
       );
     }
     // "ran": turn started; complexity is steered silently by the agent.
   } catch (err) {
     log.warn(`submit failed for chat ${chatId}: ${(err as Error).message}`);
-    await send(deps, chatId, `\u274C Couldn't start your message: ${(err as Error).message}`);
+    await send(
+      deps,
+      chatId,
+      `\u274C Couldn't start your message: ${(err as Error).message}`,
+      threadId,
+      replyTo,
+    );
   }
 }
 
-async function send(deps: BotDeps, chatId: number, text: string): Promise<void> {
+async function send(
+  deps: BotDeps,
+  chatId: number,
+  text: string,
+  threadId?: number,
+  replyTo?: number,
+): Promise<void> {
   try {
-    await deps.api.sendMessage(chatId, text);
+    const extra: Record<string, unknown> = {};
+    if (threadId !== undefined) extra.message_thread_id = threadId;
+    if (replyTo !== undefined) {
+      extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
+    }
+    await deps.api.sendMessage(chatId, text, extra);
   } catch {
     /* non-fatal */
   }