grok-telegram-bot 2.3.1 → 2.5.0

package/src/bot/handlers/session-card.ts

@@ -10,6 +10,7 @@ import { InlineKeyboard } from "grammy";
 import { basename } from "node:path";
 import { progressBar } from "../../render/progress.js";
 import type { SessionMeta } from "../../sessions/types.js";
+// Note: callers may pass `comment` from runtime or history (last-turn outcome).
 
 export interface SessionCardExtras {
   /** Context-usage %, when the session is loaded in the current ACP process. */
@@ -22,6 +23,11 @@ export interface SessionCardExtras {
   selfPid?: number;
   /** Latest task-completion % (0–100) for this session, if this chat runs it. */
   progress?: number;
+  /**
+   * Last user prompt (and, when busy, last AI thinking on a second line).
+   * Overrides `m.comment` when provided by the controlling chat runtime.
+   */
+  comment?: string;
 }
 
 export interface SessionCard {
@@ -29,14 +35,28 @@ export interface SessionCard {
   keyboard: InlineKeyboard;
 }
 
+const COMMENT_LINE_MAX = 250;
+
 /** Build the card body + buttons for one session. */
 export function buildSessionCard(m: SessionMeta, extra: SessionCardExtras = {}): SessionCard {
   const dot = m.active ? "\u{1F7E2}" : "\u26AA";
   const state = m.active ? `running${m.lockPid ? ` \u00B7 pid ${m.lockPid}` : ""}` : "idle";
   const proj = m.cwd ? basename(m.cwd) : "(no project)";
+  const comment = (extra.comment || m.comment || "").trim();
 
   const lines = [`${dot} ${m.title}`, `\u{1F4C1} ${proj}`];
   if (m.cwd) lines.push(`   ${m.cwd}`);
+  // Last user prompt always; second line = thinking while running.
+  if (comment) {
+    const busy = m.active || typeof extra.progress === "number";
+    const parts = comment.split("\n").map((l) => l.trim()).filter(Boolean);
+    parts.forEach((part, i) => {
+      const clipped = part.length > COMMENT_LINE_MAX ? part.slice(0, COMMENT_LINE_MAX - 1) + "\u2026" : part;
+      // First line: user prompt; later lines (thinking): hourglass when busy.
+      const icon = i === 0 ? (busy ? "\u23F3" : "\u{1F4AC}") : "\u{1F9E0}";
+      lines.push(`${icon} ${clipped}`);
+    });
+  }
   lines.push(`\u{1F552} updated ${relTime(m.updatedAt)} \u00B7 created ${relTime(m.createdAt)}`);
   const ctx = typeof extra.contextPct === "number" ? ` \u00B7 \u{1F9E0} ctx ${Math.round(extra.contextPct)}%` : "";
   lines.push(`\u{1F4CA} ${state} \u00B7 \u{1F4DC} history ${humanSize(m.historyBytes)}${ctx}`);

package/src/bot/handlers/sessions.ts

@@ -10,7 +10,7 @@
 import { type Bot, type Context, InlineKeyboard } from "grammy";
 import { basename } from "node:path";
 import type { BotDeps } from "../deps.js";
-import { readHistory } from "../../sessions/history.js";
+import { readHistory, readLastUserPrompt } from "../../sessions/history.js";
 import type { SessionMeta } from "../../sessions/types.js";
 import { refreshMenu } from "../menu/refresh.js";
 import { showHistory } from "./history.js";
@@ -22,16 +22,35 @@ const UUID = "([0-9a-fA-F-]{36})";
 
 export async function showSessions(ctx: Context, deps: BotDeps, query?: string): Promise<void> {
   const q = (query ?? "").trim().toLowerCase();
+  const { resolveScope } = await import("../scope.js");
+  const scope = resolveScope(ctx, deps);
   let metas = deps.store.list(q ? 400 : 200);
+  // In a forum topic, only show sessions for this project path (includes bot DMs).
+  if (scope.isForum && scope.projectPath) {
+    const want = scope.projectPath.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+    metas = metas.filter((m) => (m.cwd || "").replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase() === want);
+  }
   if (q) {
     metas = metas.filter((m) => `${m.title} ${m.cwd} ${m.sessionId}`.toLowerCase().includes(q));
   }
   if (metas.length === 0) {
     await deps.ephemeral.open(ctx);
-    await deps.ephemeral.reply(ctx, q ? `No sessions match "${q}".` : "No saved sessions found in ~/.grok/sessions/cli.");
+    await deps.ephemeral.reply(
+      ctx,
+      q
+        ? `No sessions match "${q}".`
+        : scope.isForum
+          ? `No saved sessions for project **${scope.projectName}** yet.`
+          : "No saved sessions found in ~/.grok/sessions/cli.",
+    );
     return;
   }
-  deps.menuCache.setSessions(ctx.chat!.id, metas, q ? `Sessions matching "${q}"` : "Recent sessions");
+  const heading = scope.isForum
+    ? `Sessions \u00B7 ${scope.projectName ?? "topic"}`
+    : q
+      ? `Sessions matching "${q}"`
+      : "Recent sessions";
+  deps.menuCache.setSessions(ctx.chat!.id, metas, heading);
   await renderSessionPage(ctx, deps, 0);
 }
 
@@ -50,10 +69,26 @@ async function renderSessionPage(ctx: Context, deps: BotDeps, page: number): Pro
   const pageStr = totalPages > 1 ? ` \u00B7 page ${p + 1}/${totalPages}` : "";
   await deps.ephemeral.reply(ctx, `\u{1F5C2} ${heading} \u2014 ${metas.length} total${liveStr}${pageStr}`);
 
+  const { resolveScope } = await import("../scope.js");
+  const scope = resolveScope(ctx, deps);
   for (const m of slice) {
     const contextPct = deps.acp.metadataFor(m.sessionId)?.contextUsagePercentage;
-    const progress = deps.registry.controller(ctx.chat!.id).progressFor(m.sessionId);
-    const { text, keyboard } = buildSessionCard(m, { contextPct, selfPid: deps.acp.pid, progress });
+    const ctrl = scope.controller;
+    const progress =
+      ctrl.progressFor(m.sessionId) ??
+      deps.registry.forumControllerForSession(m.sessionId)?.progressFor(m.sessionId);
+    // Live runtime (user + thinking) → last user from history → disk comment.
+    const comment =
+      ctrl.commentFor(m.sessionId) ||
+      deps.registry.forumControllerForSession(m.sessionId)?.commentFor(m.sessionId) ||
+      readLastUserPrompt(deps.store.jsonlPath(m.sessionId)) ||
+      m.comment;
+    const { text, keyboard } = buildSessionCard(m, {
+      contextPct,
+      selfPid: deps.acp.pid,
+      progress,
+      comment,
+    });
     await deps.ephemeral.reply(ctx, text, { reply_markup: keyboard });
   }
 
@@ -86,8 +121,12 @@ export function registerSessions(bot: Bot, deps: BotDeps): void {
   });
 
   bot.command("unwatch", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
-    await ctx.reply(rt.stopWatch() ? "\u{1F6D1} Stopped watching." : "Not watching anything.");
+    const { resolveScope } = await import("../scope.js");
+    const scope = resolveScope(ctx, deps);
+    await ctx.reply(
+      scope.rt.stopWatch() ? "\u{1F6D1} Stopped watching." : "Not watching anything.",
+      scope.threadExtra,
+    );
   });
 
   bot.callbackQuery(new RegExp(`^sess:${UUID}$`), async (ctx) => {
@@ -99,19 +138,39 @@ export function registerSessions(bot: Bot, deps: BotDeps): void {
     }
     await ctx.answerCallbackQuery();
     await deps.ephemeral.clear(ctx.chat!.id); // remove the session cards
-    const fgCwd = deps.registry.get(ctx.chat!.id).cwd;
+    const { resolveScope } = await import("../scope.js");
+    const scope = resolveScope(ctx, deps);
+    const fgCwd = scope.rt.cwd;
     const cwd = meta.cwd || fgCwd;
     const projectName = basename(meta.cwd || fgCwd) || "session";
+    if (scope.controller.fixedCwd) {
+      const a = scope.controller.fixedCwd.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+      const b = cwd.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+      if (a !== b) {
+        await ctx.reply("That session is for a different project than this topic.", scope.threadExtra);
+        return;
+      }
+    }
     const prior = readHistory(deps.store.jsonlPath(id), 24);
     try {
-      const { result, alreadyControlled } = await deps.registry
-        .controller(ctx.chat!.id)
-        .addAttach(id, cwd, projectName, prior);
-      await ctx.reply(alreadyControlled ? `\u{1F500} Switched to ${meta.title}` : connectMessage(result, meta));
+      // Avoid dual ownership across DM ↔ topic controllers.
+      for (const c of deps.registry.allForumControllers()) {
+        if (c !== scope.controller && c.findBySession(id)) await c.close(id);
+      }
+      const { result, alreadyControlled } = await scope.controller.addAttach(
+        id,
+        cwd,
+        projectName,
+        prior,
+      );
+      await ctx.reply(
+        alreadyControlled ? `\u{1F500} Switched to ${meta.title}` : connectMessage(result, meta),
+        scope.threadExtra,
+      );
       await refreshMenu(ctx, deps, `\u{1F4C2} ${meta.title}`);
       await showHistory(deps, ctx.chat!.id, id, meta);
     } catch (err) {
-      await ctx.reply(`\u274C Could not connect: ${(err as Error).message}`);
+      await ctx.reply(`\u274C Could not connect: ${(err as Error).message}`, scope.threadExtra);
     }
   });
 
@@ -126,10 +185,12 @@ export function registerSessions(bot: Bot, deps: BotDeps): void {
     const id = ctx.match![1]!;
     await ctx.answerCallbackQuery();
     const meta = deps.store.get(id);
-    const rt = deps.registry.get(ctx.chat!.id);
-    rt.startWatch(deps.store.jsonlPath(id));
+    const { resolveScope } = await import("../scope.js");
+    const scope = resolveScope(ctx, deps);
+    scope.rt.startWatch(deps.store.jsonlPath(id));
     await ctx.reply(
       `\u{1F4E1} Watching live: ${meta?.title ?? id.slice(0, 8)}\nNew activity streams here. Send /unwatch to stop.`,
+      scope.threadExtra,
     );
   });
 }

package/src/bot/handlers/usage.ts

@@ -1,7 +1,10 @@
 /**
- * /usage — show account info and the current session's context usage.
+ * /usage — Grok CLI live monthly quota + session context + bot-tracked
+ * per-account turn stats.
  */
 import type { Bot, Context } from "grammy";
+import type { StoredAccount } from "../../app/accounts.js";
+import { formatCliBillingLines } from "../../app/usage.js";
 import type { BotDeps } from "../deps.js";
 
 export async function showUsage(ctx: Context, deps: BotDeps): Promise<void> {
@@ -10,29 +13,128 @@ export async function showUsage(ctx: Context, deps: BotDeps): Promise<void> {
   const acct = await deps.usage.account();
   const meta = rt.contextInfo();
   const ctx100 = meta?.contextUsagePercentage;
-  const savedCount = deps.accounts.list().length;
+  const list = deps.accounts.list();
+  const activeId = deps.accounts.activeAccountId();
+  const activeMeta = activeId ? deps.accounts.get(activeId) : undefined;
+  const { billing, error: billingError } = await deps.usage.cliBilling();
 
-  const lines = [
-    "\u{1F4CA} Usage & account",
-    acct?.email ? `\u{1F464} ${acct.email}` : "",
-    acct?.accountType ? `\u{1F511} ${acct.accountType}${acct.region ? ` \u00B7 ${acct.region}` : ""}` : "",
+  const lines: string[] = [
+    "\u{1F4CA} Usage & accounts",
     "",
-    `\u{1F9F5} Session: ${rt.sessionId ? rt.sessionId.slice(0, 8) : "none"}`,
-    `\u{1F9E9} Model: ${rt.model || "default"}`,
-    `\u{1F4CA} Context used: ${ctx100 !== undefined ? `${ctx100.toFixed(0)}%` : "\u2014"}`,
-    `\u{1F501} Turns this session: ${rt.turns}`,
-    meta?.credits !== undefined ? `\u{1FA99} Credits used: ${meta.credits.toLocaleString("en-US")}` : "",
-    meta?.effort ? `\u{1F9E0} Effort: ${meta.effort}` : "",
-    savedCount > 0 ? `\u{1F465} Saved accounts: ${savedCount} \u00B7 /accounts to switch` : "",
+    "\u{1F464} Current login",
+    acct?.email ? `  ${acct.email}` : "  (identity unknown)",
+  ];
+  if (acct?.accountType) {
+    lines.push(`  \u{1F511} ${acct.accountType}${acct.region ? ` \u00B7 ${acct.region}` : ""}`);
+  }
+  if (acct?.teamId) lines.push(`  Team: ${acct.teamId.slice(0, 8)}\u2026`);
+  if (activeMeta) {
+    const uLine = deps.accounts.formatUsageLine(activeMeta);
+    lines.push(`  Saved as: ${activeMeta.label}`);
+    if (uLine) lines.push(`  Bot-tracked: ${uLine}`);
+  }
+
+  lines.push("");
+  if (billing) {
+    lines.push(...formatCliBillingLines(billing));
+  } else {
+    lines.push(
+      "\u{1F4B3} Grok CLI monthly quota",
+      `  \u26A0\uFE0F ${billingError || "unavailable"}`,
+      "  (Requires `grok login` OIDC token — not XAI_API_KEY alone.)",
+    );
+  }
+
+  lines.push(
     "",
-    "\u2139\uFE0F Full billing/quota lives in the Grok app; grok doesn't expose limits headlessly.",
-  ].filter(Boolean);
+    "\u{1F9F5} This session (ACP)",
+    `  Id: ${rt.sessionId ? rt.sessionId.slice(0, 8) : "none"}`,
+    `  Model: ${rt.model || "default"}`,
+    `  Context used: ${ctx100 !== undefined ? `${ctx100.toFixed(0)}%` : "\u2014"}`,
+    `  Turns this session: ${rt.turns}`,
+  );
+  if (meta?.credits !== undefined) {
+    lines.push(`  Credits (session report): ${fmtNum(meta.credits)}`);
+  }
+  if (meta?.effort) lines.push(`  Effort: ${meta.effort}`);
+  if (meta?.totalTokens !== undefined) {
+    lines.push(`  Tokens (session report): ${meta.totalTokens.toLocaleString("en-US")}`);
+  }
+
+  if (list.length > 0) {
+    lines.push("", "\u{1F465} Saved accounts (bot-tracked turns on this machine)");
+    for (const a of list) {
+      lines.push(accountUsageBlock(deps, a, a.id === activeId));
+    }
+    const totals = aggregate(list);
+    lines.push(
+      "",
+      `\u{1F4CA} Bot totals: ${totals.turns} turn${totals.turns === 1 ? "" : "s"}` +
+        (totals.credits > 0 ? ` \u00B7 ${fmtNum(totals.credits)} session credits` : "") +
+        ` \u00B7 ${totals.withUsage}/${list.length} accounts used`,
+    );
+  } else {
+    lines.push("", "\u{1F465} No saved accounts yet \u2014 /accounts to save & switch.");
+  }
+
+  lines.push(
+    "",
+    "\u2139\uFE0F Monthly quota is live from Grok CLI (`cli-chat-proxy` billing). Bot-tracked turns are local to this bot.",
+  );
+
+  if (!acct) lines.splice(3, 0, "  (account info unavailable \u2014 is grok logged in?)");
 
-  if (!acct) lines.splice(1, 0, "(account info unavailable \u2014 is grok logged in?)");
   await deps.ephemeral.open(ctx);
   await deps.ephemeral.reply(ctx, lines.join("\n"));
 }
 
+function accountUsageBlock(deps: BotDeps, a: StoredAccount, active: boolean): string {
+  const mark = a.warning ? "\u26A0\uFE0F" : active ? "\u2705" : "\u{1F464}";
+  const u = a.usage;
+  const head = `${mark} ${a.label}${active ? " (active)" : ""}`;
+  if (!u || (u.turns <= 0 && u.credits <= 0 && !u.lastUsedAt)) {
+    return `${head}\n  no bot-tracked usage yet`;
+  }
+  const bits: string[] = [];
+  bits.push(`${u.turns || 0} turn${(u.turns || 0) === 1 ? "" : "s"}`);
+  if (u.credits > 0) bits.push(`${fmtNum(u.credits)} session credits`);
+  if (u.lastTurnCredits !== undefined) bits.push(`last turn ${fmtNum(u.lastTurnCredits)}`);
+  if (u.lastContextPct !== undefined) bits.push(`last ctx ${u.lastContextPct.toFixed(0)}%`);
+  if (u.lastUsedAt) bits.push(`last ${shortWhen(u.lastUsedAt)}`);
+  return `${head}\n  ${bits.join(" \u00B7 ")}`;
+}
+
+function aggregate(list: StoredAccount[]): { turns: number; credits: number; withUsage: number } {
+  let turns = 0;
+  let credits = 0;
+  let withUsage = 0;
+  for (const a of list) {
+    const u = a.usage;
+    if (!u) continue;
+    turns += u.turns || 0;
+    credits += u.credits || 0;
+    if (u.turns > 0 || u.credits > 0 || u.lastUsedAt) withUsage++;
+  }
+  return { turns, credits, withUsage };
+}
+
+function fmtNum(n: number): string {
+  if (!Number.isFinite(n)) return String(n);
+  if (Number.isInteger(n)) return n.toLocaleString("en-US");
+  return n.toFixed(2);
+}
+
+function shortWhen(iso: string): string {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return iso.slice(0, 10);
+  const sec = Math.max(0, Math.round((Date.now() - t) / 1000));
+  if (sec < 60) return "just now";
+  if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
+  if (sec < 86_400) return `${Math.floor(sec / 3600)}h ago`;
+  if (sec < 86_400 * 14) return `${Math.floor(sec / 86_400)}d ago`;
+  return new Date(t).toISOString().slice(0, 10);
+}
+
 export function registerUsage(bot: Bot, deps: BotDeps): void {
   bot.command("usage", (ctx) => showUsage(ctx, deps));
 }

package/src/bot/handlers/voice.ts

@@ -14,8 +14,16 @@ import { extractReplyContext } from "../reply-context.js";
 
 const log = createLogger("voice");
 
+type VoiceMediaKind = "voice" | "audio" | "video_note";
+
 export function registerVoice(bot: Bot, deps: BotDeps): void {
-  const handle = async (ctx: Context, fileId: string, mime: string, name: string): Promise<void> => {
+  const handle = async (
+    ctx: Context,
+    fileId: string,
+    mime: string,
+    name: string,
+    mediaKind: VoiceMediaKind,
+  ): Promise<void> => {
     const chatId = ctx.chat!.id;
     if (deps.wizard.isActive(chatId)) {
       await ctx.reply("Finish or /cancel the task wizard before sending voice.");
@@ -36,11 +44,41 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
         await ctx.reply("\u{1F399} I couldn't make out any speech.");
         return;
       }
-      await ctx.reply(`\u{1F399} \u201C${text}\u201D`);
-      const rt = deps.registry.get(chatId);
+      const { resolveScope } = await import("../scope.js");
+      const { adoptUserPrompt } = await import("../prompt-anchor.js");
+      const scope = resolveScope(ctx, deps);
       const quoted = extractReplyContext(ctx);
-      const outcome = await rt.submit(textPrompt(text, ctx.message?.message_id, quoted));
-      if (outcome === "queued") await ctx.reply("\u{1F4E5} Queued \u2014 will run after the current task.");
+      const userMsgId = ctx.message?.message_id;
+      const media =
+        mediaKind === "video_note"
+          ? [{ type: "video_note" as const, fileId }]
+          : mediaKind === "voice"
+            ? [{ type: "voice" as const, fileId }]
+            : [{ type: "audio" as const, fileId, fileName: name }];
+      const anchor = await adoptUserPrompt(deps.api, {
+        chatId,
+        text: `\u201C${text}\u201D`,
+        userMessageIds: userMsgId !== undefined ? [userMsgId] : [],
+        messageThreadId: scope.threadExtra.message_thread_id,
+        projectName: scope.rt.projectName,
+        prefix: "\u{1F399} Voice",
+        media,
+      });
+      const outcome = await scope.rt.submit(
+        textPrompt(text, anchor?.replyTo ?? userMsgId, quoted, {
+          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 \u2014 will run after the current task.", extra);
+      }
     } catch (e) {
       log.warn("voice failed:", (e as Error).message);
       await ctx.reply(`\u274C Voice transcription failed: ${(e as Error).message}`);
@@ -48,7 +86,13 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
   };
 
   bot.on("message:voice", (ctx) =>
-    handle(ctx, ctx.message.voice.file_id, ctx.message.voice.mime_type || "audio/ogg", "voice.ogg"),
+    handle(
+      ctx,
+      ctx.message.voice.file_id,
+      ctx.message.voice.mime_type || "audio/ogg",
+      "voice.ogg",
+      "voice",
+    ),
   );
   bot.on("message:audio", (ctx) =>
     handle(
@@ -56,10 +100,11 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
       ctx.message.audio.file_id,
       ctx.message.audio.mime_type || "audio/mpeg",
       ctx.message.audio.file_name || "audio.mp3",
+      "audio",
     ),
   );
   bot.on("message:video_note", (ctx) =>
-    handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4"),
+    handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4", "video_note"),
   );
 }
 

package/src/bot/image-return.ts

@@ -129,6 +129,8 @@ export interface SendImagesOptions {
   max: number;
   /** Optional Telegram message id to thread replies under. */
   replyTo?: number;
+  /** Forum topic — required so agent images land in the right topic. */
+  messageThreadId?: number;
 }
 
 /** Send the valid, fresh, not-yet-sent images as documents. Returns how many were sent. */
@@ -139,10 +141,11 @@ export async function sendImages(
   opts: SendImagesOptions,
 ): Promise<number> {
   let sent = 0;
-  const replyExtra =
-    opts.replyTo !== undefined
-      ? { reply_parameters: { message_id: opts.replyTo, allow_sending_without_reply: true } }
-      : {};
+  const extra: Record<string, unknown> = {};
+  if (opts.replyTo !== undefined) {
+    extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
+  }
+  if (opts.messageThreadId !== undefined) extra.message_thread_id = opts.messageThreadId;
   for (const path of paths) {
     if (sent >= opts.max) break;
     if (opts.already.has(path)) continue;
@@ -161,7 +164,7 @@ export async function sendImages(
       const file = new InputFile(path, basename(path));
       await api.sendDocument(chatId, file, {
         caption: basename(path),
-        ...replyExtra,
+        ...extra,
       });
       sent++;
       log.debug(`sent document ${path}`);

package/src/bot/menu/ephemeral.ts

@@ -95,11 +95,21 @@ export class Ephemeral {
   async reply(ctx: Context, text: string, extra: Record<string, unknown> = {}): Promise<number | undefined> {
     const chatId = ctx.chat?.id;
     if (chatId === undefined) return undefined;
+    // Stay in the forum topic when the trigger message was in a thread.
+    const msg = ctx.message ?? ctx.callbackQuery?.message;
+    const threadId =
+      msg && "message_thread_id" in msg
+        ? (msg as { message_thread_id?: number }).message_thread_id
+        : undefined;
+    const merged =
+      threadId !== undefined && extra.message_thread_id === undefined
+        ? { ...extra, message_thread_id: threadId }
+        : extra;
     return this.serialize(chatId, async () => {
       try {
-        const msg = await ctx.reply(text, extra);
-        this.remember(chatId, msg.message_id);
-        return msg.message_id;
+        const m = await ctx.reply(text, merged);
+        this.remember(chatId, m.message_id);
+        return m.message_id;
       } catch {
         return undefined;
       }

package/src/bot/menu/keyboard.ts

@@ -1,33 +1,73 @@
 /**
  * Menu surfaces:
- *  - a tiny PERSISTENT bar (☰ Menu · 🧭 Running · ⏹ Stop) — minimal footprint;
- *  - a full, organized INLINE menu opened on demand (and hideable).
- * Live state (project/agent/model/reasoning/context) lives in the pinned panel,
- * so the bar stays clean.
+ *  - PERSISTENT bar (reply keyboard): ☰ Menu · 🆕 New session / 🧭 Running · ⏹ Stop
+ *    — primary place for New session in private chats (not the inline Menu message).
+ *  - INLINE menu message (opened via ☰ Menu or /menu) — settings & navigation.
+ *    Forum topics: reply keyboards are unreliable, so New stays on the topic inline menu.
+ * Live state lives in the pinned status panel so the bar stays clean.
  */
 import { InlineKeyboard, Keyboard } from "grammy";
 
 export const MENU_BTN = "\u2630 Menu"; // ☰
+/** Persistent bar + forum topic control — brand-new session (same as /new). */
+export const NEW_BTN = "\u{1F195} New session";
 export const RUNNING_BTN = "\u{1F9ED} Running";
 export const STOP_BTN = "\u23F9 Stop";
-export const BAR_LABELS = [MENU_BTN, RUNNING_BTN, STOP_BTN];
+export const BAR_LABELS = [MENU_BTN, NEW_BTN, RUNNING_BTN, STOP_BTN];
 
-/** The always-visible compact bar. */
+/** The always-visible compact bar (private chats; best-effort in groups). */
 export function compactKeyboard(): Keyboard {
-  return new Keyboard().text(MENU_BTN).text(RUNNING_BTN).text(STOP_BTN).resized().persistent();
+  return new Keyboard()
+    .text(MENU_BTN)
+    .text(NEW_BTN)
+    .row()
+    .text(RUNNING_BTN)
+    .text(STOP_BTN)
+    .resized()
+    .persistent();
 }
 
 /** The full, grouped inline menu (opened via ☰ Menu or /menu). */
-export function mainMenuInline(state: { agent: string; model: string; reasoning: string }): InlineKeyboard {
+export function mainMenuInline(state: {
+  model: string;
+  reasoning: string;
+  /** Forum topic scope — hide project switch; label topic sessions. */
+  forumTopic?: { name: string; account?: string };
+}): InlineKeyboard {
   const t = (s: string, n: number): string => (s.length > n ? s.slice(0, n - 1) + "\u2026" : s);
-  return new InlineKeyboard()
-    .text("\u{1F4C1} Project", "m:project")
-    .text("\u{1F195} New", "m:new")
+  const kb = new InlineKeyboard();
+
+  if (state.forumTopic) {
+    // Groups/topics: control first (no reliable reply-keyboard bar). New session here.
+    kb.text("\u23F9 Stop", "m:stop")
+      .text("\u{1F9ED} Running", "m:running")
+      .row()
+      .text(NEW_BTN, "m:new")
+      .text("\u{1F5C2} Sessions", "m:sessions")
+      .row()
+      .text(`\u{1F4C1} ${t(state.forumTopic.name, 28)}`, "m:topicinfo")
+      .row()
+      .text("\u{1F4E5} Import session", "m:import")
+      .row()
+      .text(`\u{1F9E9} Model \u00B7 ${t(state.model, 24)}`, "m:model")
+      .row()
+      .text(`\u{1F9E0} Reasoning \u00B7 ${t(state.reasoning, 24)}`, "m:reasoning")
+      .row();
+    if (state.forumTopic.account) {
+      kb.text(`\u{1F465} Account \u00B7 ${t(state.forumTopic.account, 20)}`, "m:accounts").row();
+    }
+    kb.text("\u{1F4CA} Status", "m:status").text("\u2716 Close", "m:close");
+    return kb;
+  }
+
+  // Private chat: New session is on the persistent bar + /new — not on this message.
+  kb.text("\u{1F4C1} Project", "m:project")
+    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
+    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F9ED} Running", "m:running")
-    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
-    .text(`\u{1F916} Agent \u00B7 ${t(state.agent, 24)}`, "m:agent")
+    .text("\u{1F4E5} Import session", "m:import")
     .row()
     .text(`\u{1F9E9} Model \u00B7 ${t(state.model, 24)}`, "m:model")
     .row()
@@ -40,10 +80,10 @@ export function mainMenuInline(state: { agent: string; model: string; reasoning:
     .text("\u{1F465} Accounts", "m:accounts")
     .row()
     .text("\u{1F9E9} MCP", "m:mcp")
-    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F6D1} Kill all", "m:killall")
     .row()
     .text("\u2328\uFE0F Show bar", "m:showbar")
     .text("\u{1F648} Hide bar", "m:hidebar")
     .text("\u2716 Close", "m:close");
+  return kb;
 }

package/src/bot/menu/refresh.ts

@@ -4,10 +4,12 @@
  */
 import type { Context } from "grammy";
 import type { BotDeps } from "../deps.js";
+import { resolveScope } from "../scope.js";
 import { compactKeyboard } from "./keyboard.js";
 
 export async function refreshMenu(ctx: Context, deps: BotDeps, text: string): Promise<void> {
   const chatId = ctx.chat!.id;
-  await ctx.reply(text, { reply_markup: compactKeyboard() });
+  const scope = resolveScope(ctx, deps);
+  await ctx.reply(text, { reply_markup: compactKeyboard(), ...scope.threadExtra });
   await deps.statusPanel.refresh(chatId);
 }