grok-telegram-bot 2.3.1 → 2.5.0

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,88 +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 */
   }

package/src/bot/handlers/photo.ts

@@ -2,11 +2,15 @@
  * Photo & image-document handler. Downloads images (including multi-image
  * albums / media groups) and submits them to Grok as ACP image content blocks
  * alongside the caption text.
+ *
+ * User media messages are replaced by a bot prompt anchor (`#prompt_<id>`);
+ * the agent still receives the downloaded image bytes.
  */
 import type { Bot, Context } from "grammy";
 import type { PromptImage } from "../../app/types.js";
 import { createLogger } from "../../logger.js";
 import type { BotDeps } from "../deps.js";
+import { type AdoptMediaItem, adoptUserPrompt } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
 
 const log = createLogger("photo");
@@ -15,19 +19,31 @@ const GROUP_DEBOUNCE_MS = 900;
 interface GroupBuffer {
   chatId: number;
   caption: string;
+  /** Agent-bound image bytes (may be shorter than media if a download failed). */
   images: PromptImage[];
-  replyTo?: number;
+  /** Chat re-post descriptors (file_id + correct photo vs document kind). */
+  media: AdoptMediaItem[];
+  /** User Telegram message ids in this album (for delete after anchor). */
+  userMessageIds: number[];
   quoted?: string;
+  threadId?: number;
   timer: NodeJS.Timeout;
 }
 
 export function registerPhotos(bot: Bot, deps: BotDeps): void {
   const groups = new Map<string, GroupBuffer>();
 
-  const onMedia = async (ctx: Context, image: PromptImage | undefined, caption: string): Promise<void> => {
-    if (!image) return;
+  const onMedia = async (
+    ctx: Context,
+    image: PromptImage | undefined,
+    mediaItem: AdoptMediaItem | undefined,
+    caption: string,
+  ): Promise<void> => {
+    // Still re-post to chat when download fails — user must not lose the file.
+    if (!mediaItem?.fileId) return;
     const chatId = ctx.chat!.id;
-    const replyTo = ctx.message?.message_id;
+    const msgId = ctx.message?.message_id;
+    const threadId = ctx.message?.message_thread_id;
     const quoted = extractReplyContext(ctx);
 
     // Don't hijack the task wizard.
@@ -36,9 +52,21 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
       return;
     }
 
+    const images = image ? [image] : [];
+    const media = [mediaItem];
+
     const groupId = ctx.message?.media_group_id;
     if (!groupId) {
-      await submit(deps, chatId, caption, [image], replyTo, quoted);
+      await submit(
+        deps,
+        chatId,
+        caption,
+        images,
+        media,
+        msgId !== undefined ? [msgId] : [],
+        quoted,
+        threadId,
+      );
       return;
     }
 
@@ -46,17 +74,21 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
     const existing = groups.get(groupId);
     if (existing) {
       clearTimeout(existing.timer);
-      existing.images.push(image);
+      if (image) existing.images.push(image);
+      existing.media.push(mediaItem);
       if (caption) existing.caption = caption;
       if (quoted && !existing.quoted) existing.quoted = quoted;
+      if (msgId !== undefined) existing.userMessageIds.push(msgId);
       existing.timer = setTimeout(() => flush(groups, groupId, deps), GROUP_DEBOUNCE_MS);
     } else {
       groups.set(groupId, {
         chatId,
         caption,
-        images: [image],
-        replyTo,
+        images,
+        media,
+        userMessageIds: msgId !== undefined ? [msgId] : [],
         quoted,
+        threadId,
         timer: setTimeout(() => flush(groups, groupId, deps), GROUP_DEBOUNCE_MS),
       });
     }
@@ -65,15 +97,33 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
   bot.on("message:photo", async (ctx) => {
     const photos = ctx.message.photo;
     const largest = photos[photos.length - 1];
-    const image = largest ? await download(ctx, largest.file_id, "image/jpeg", deps.cfg.token) : undefined;
-    await onMedia(ctx, image, ctx.message.caption ?? "");
+    const fileId = largest?.file_id;
+    const image = fileId
+      ? await download(ctx, fileId, "image/jpeg", deps.cfg.token)
+      : undefined;
+    await onMedia(
+      ctx,
+      image,
+      fileId ? { type: "photo", fileId } : undefined,
+      ctx.message.caption ?? "",
+    );
   });
 
   bot.on("message:document", async (ctx, next) => {
     const doc = ctx.message.document;
     if (!doc.mime_type?.startsWith("image/")) return next(); // let document-handler logic pass
     const image = await download(ctx, doc.file_id, doc.mime_type, deps.cfg.token);
-    await onMedia(ctx, image, ctx.message.caption ?? "");
+    // Image-as-document must re-post as document — photo file_ids are a different kind.
+    await onMedia(
+      ctx,
+      image,
+      {
+        type: "document",
+        fileId: doc.file_id,
+        fileName: doc.file_name ?? undefined,
+      },
+      ctx.message.caption ?? "",
+    );
   });
 }
 
@@ -81,7 +131,16 @@ async function flush(groups: Map<string, GroupBuffer>, groupId: string, deps: Bo
   const buf = groups.get(groupId);
   if (!buf) return;
   groups.delete(groupId);
-  await submit(deps, buf.chatId, buf.caption, buf.images, buf.replyTo, buf.quoted);
+  await submit(
+    deps,
+    buf.chatId,
+    buf.caption,
+    buf.images,
+    buf.media,
+    buf.userMessageIds,
+    buf.quoted,
+    buf.threadId,
+  );
 }
 
 async function submit(
@@ -89,15 +148,63 @@ async function submit(
   chatId: number,
   caption: string,
   images: PromptImage[],
-  replyTo?: number,
+  media: AdoptMediaItem[],
+  userMessageIds: number[],
   quoted?: string,
+  threadId?: number,
 ): Promise<void> {
-  const rt = deps.registry.get(chatId);
-  const outcome = await rt.submit({ text: caption, images, replyTo, quotedText: quoted });
+  let rt = deps.registry.get(chatId);
+  if (deps.forum?.isActiveForumChat(chatId) && threadId !== undefined) {
+    const { forumThreadId } = await import("../../forum/thread.js");
+    const tid = forumThreadId(threadId);
+    const resolved = deps.forum.resolveCwd(tid);
+    if (resolved) {
+      rt = deps.registry.getForumTopic(chatId, tid, resolved.cwd, resolved.projectName);
+    }
+  }
+
+  const n = Math.max(images.length, media.length);
+  const label =
+    n === 1
+      ? "\u{1F4F7} Image"
+      : `\u{1F4F7} ${n} images`;
+  const body = caption.trim()
+    ? caption
+    : n === 1
+      ? "(image attached)"
+      : `(${n} images attached)`;
+
+  const anchor = await adoptUserPrompt(deps.api, {
+    chatId,
+    text: body,
+    userMessageIds,
+    messageThreadId: threadId,
+    projectName: rt.projectName,
+    prefix: label,
+    media,
+  });
+
+  // Agent gets whatever bytes we could download (may be empty if download failed).
+  const outcome = await rt.submit({
+    text: caption,
+    images,
+    replyTo: anchor?.replyTo ?? userMessageIds[0],
+    promptId: anchor?.promptId,
+    quotedText: quoted,
+  });
   if (outcome === "queued") {
+    const extra: Record<string, unknown> =
+      threadId !== undefined ? { message_thread_id: threadId } : {};
+    if (anchor?.replyTo !== undefined) {
+      extra.reply_parameters = {
+        message_id: anchor.replyTo,
+        allow_sending_without_reply: true,
+      };
+    }
     await deps.api.sendMessage(
       chatId,
-      `\u{1F4E5} Queued ${images.length} image${images.length > 1 ? "s" : ""} \u2014 will run after the current task.`,
+      `\u{1F4E5} Queued ${n} image${n > 1 ? "s" : ""} \u2014 will run after the current task.`,
+      extra,
     );
   }
 }

package/src/bot/handlers/running.ts

@@ -7,7 +7,7 @@ import { type Bot, type Context, InlineKeyboard } from "grammy";
 import type { RunningSession, SwitchResult } from "../chat-controller.js";
 import type { BotDeps } from "../deps.js";
 import type { HistoryEntry } from "../../sessions/types.js";
-import { jsonlMtimeMs, readFirstPrompt } from "../../sessions/history.js";
+import { jsonlMtimeMs, readFirstPrompt, readLastUserPrompt } from "../../sessions/history.js";
 import { progressBar } from "../../render/progress.js";
 import { refreshMenu } from "../menu/refresh.js";
 import { sendMarkdownDoc } from "../telegram-io.js";
@@ -49,29 +49,51 @@ function cleanPrompt(raw: string): string {
 }
 
 /** Build a rich card (plain text, no MarkdownV2) + buttons for one controlled
- *  session: Switch / History / Close. */
+ *  session: Switch / History / Close.
+ *
+ *  Comment:
+ *    always — last user prompt (≤250)
+ *    busy   — plus last AI agent thinking on the next line (≤250)
+ */
 function buildRunningCard(s: RunningSession, deps: BotDeps, now: number): { text: string; kb: InlineKeyboard } {
   const dot = s.foreground ? "\u25B6\uFE0F" : s.busy ? "\u{1F7E0}" : "\u26AA";
   const state = s.foreground ? "foreground" : s.busy ? "working" : "idle";
 
   let when = "new";
-  let prompt = "";
+  let lastUser = "";
+  let firstPrompt = "";
   if (s.sessionId) {
     const path = deps.store.jsonlPath(s.sessionId);
     const mtime = jsonlMtimeMs(path);
     if (mtime) when = timeAgo(now - mtime);
-    prompt = cleanPrompt(readFirstPrompt(path));
+    lastUser = readLastUserPrompt(path, 40, 250);
+    firstPrompt = cleanPrompt(readFirstPrompt(path));
+    if (/session import complete/i.test(firstPrompt)) firstPrompt = "";
   }
 
+  const diskComment = s.sessionId ? deps.store.get(s.sessionId)?.comment?.trim() : undefined;
+  // Order: live runtime (user + thinking) → last user from history → disk → first prompt.
+  const comment =
+    (s.comment && s.comment.trim()) ||
+    lastUser ||
+    diskComment ||
+    firstPrompt;
+
   const meta = [when, state];
   if (s.busy) meta.push("\u23F3");
   if (s.unread > 0) meta.push(`${s.unread} \u{1F4EC} unread`);
 
-  const lines = [
-    `${dot} ${s.projectName}`,
-    prompt ? `\u{1F4AC} \u201C${trunc(prompt, 120)}\u201D` : "\u{1F4AC} (no messages yet)",
-    `\u{1F552} ${meta.join(" \u00B7 ")}`,
-  ];
+  const lines = [`${dot} ${s.projectName}`];
+  if (comment) {
+    const parts = comment.split("\n").map((l) => l.trim()).filter(Boolean);
+    parts.forEach((part, i) => {
+      const icon = i === 0 ? (s.busy ? "\u23F3" : "\u{1F4AC}") : "\u{1F9E0}";
+      lines.push(`${icon} ${trunc(part, 250)}`);
+    });
+  } else {
+    lines.push("\u{1F4AC} (no messages yet)");
+  }
+  lines.push(`\u{1F552} ${meta.join(" \u00B7 ")}`);
   if (s.progress !== undefined) lines.push(`\u{1F4C8} ${progressBar(s.progress)}`);
   if (s.sessionId) lines.push(`\u{1F194} ${s.sessionId.slice(0, 8)}`);
 
@@ -88,14 +110,55 @@ function buildRunningCard(s: RunningSession, deps: BotDeps, now: number): { text
 
 export async function showRunning(ctx: Context, deps: BotDeps): Promise<void> {
   await deps.ephemeral.open(ctx);
-  const list = dedupeBySession(deps.registry.controller(ctx.chat!.id).list());
+  const { resolveScope } = await import("../scope.js");
+  const scope = resolveScope(ctx, deps);
+  // Topic: only this topic's controlled sessions. Private: this chat + same-project forum sessions.
+  let list = dedupeBySession(scope.controller.list());
+  if (!scope.isForum) {
+    const path = scope.rt.cwd;
+    for (const fc of deps.registry.allForumControllers()) {
+      if (fc.fixedCwd && samePath(fc.fixedCwd, path)) {
+        list = dedupeBySession([...list, ...fc.list().map((s) => ({ ...s, projectName: `${s.projectName} \u00B7 topic` }))]);
+      }
+    }
+  } else {
+    // Also surface private-bot sessions for the same project path.
+    for (const chatId of deps.settings.chatIds()) {
+      if (chatId === scope.chatId) continue;
+      try {
+        const priv = deps.registry.controller(chatId);
+        for (const s of priv.list()) {
+          // Match by session cwd via store or name — use store meta if available.
+          if (s.sessionId) {
+            const meta = deps.store.get(s.sessionId);
+            if (meta?.cwd && samePath(meta.cwd, scope.rt.cwd)) {
+              list = dedupeBySession([
+                ...list,
+                { ...s, projectName: `${s.projectName} \u00B7 DM`, foreground: false },
+              ]);
+            }
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  }
   if (list.length === 0) {
-    await deps.ephemeral.reply(ctx, "No sessions controlled yet. Use \u{1F4C1} Project or /new to start one.");
+    await deps.ephemeral.reply(
+      ctx,
+      scope.isForum
+        ? "No sessions in this topic yet. Send a message or tap \u{1F195} New."
+        : "No sessions controlled yet. Use \u{1F4C1} Project or /new to start one.",
+    );
     return;
   }
   const now = Date.now();
   const shown = list.slice(0, CARD_LIMIT);
-  await deps.ephemeral.reply(ctx, `\u{1F9ED} Sessions controlled by this chat (${list.length}) \u2014 tap \u{1F500} Switch on a card:`);
+  const header = scope.isForum
+    ? `\u{1F9ED} Running in topic **${scope.projectName ?? "topic"}** (${list.length})`
+    : `\u{1F9ED} Sessions controlled by this chat (${list.length}) \u2014 tap \u{1F500} Switch on a card:`;
+  await deps.ephemeral.reply(ctx, header);
   for (const s of shown) {
     const { text, kb } = buildRunningCard(s, deps, now);
     await deps.ephemeral.reply(ctx, text, { reply_markup: kb });
@@ -105,6 +168,11 @@ export async function showRunning(ctx: Context, deps: BotDeps): Promise<void> {
   }
 }
 
+function samePath(a: string, b: string): boolean {
+  return a.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase() ===
+    b.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+
 /** Collapse any cards that share a session id (defensive — the controller
  *  already prunes duplicate runtimes, but never show the same session twice). */
 function dedupeBySession(list: RunningSession[]): RunningSession[] {
@@ -119,14 +187,76 @@ function dedupeBySession(list: RunningSession[]): RunningSession[] {
 
 /** Switch the chat to a session and show its summary + unread. */
 export async function switchAndShow(ctx: Context, deps: BotDeps, sessionId: string): Promise<void> {
-  const res = await deps.registry.controller(ctx.chat!.id).switchTo(sessionId);
+  const { resolveScope } = await import("../scope.js");
+  const scope = resolveScope(ctx, deps);
+  // Always bring the session into *this* scope's controller (never switch FG on
+  // another surface — that would dual-own one ACP session across controllers).
+  let res = await scope.controller.switchTo(sessionId);
+  if (!res) {
+    const meta = deps.store.get(sessionId);
+    let cwd = meta?.cwd;
+    let name = meta?.title || (cwd ? basenameSafe(cwd) : undefined);
+    if (!cwd) {
+      // Discover cwd from whatever controller currently lists it.
+      for (const c of [scope.controller, ...deps.registry.allForumControllers()]) {
+        const hit = c.list().find((s) => s.sessionId === sessionId);
+        if (hit) {
+          cwd = (c as { fixedCwd?: string }).fixedCwd || scope.rt.cwd;
+          name = hit.projectName || name;
+          break;
+        }
+      }
+    }
+    if (cwd) {
+      // Topic controllers are fixed-path — refuse foreign projects.
+      if (scope.controller.fixedCwd && !samePath(scope.controller.fixedCwd, cwd)) {
+        await ctx.reply(
+          "That session belongs to a different project than this topic.",
+          scope.threadExtra,
+        );
+        return;
+      }
+      // Drop dual ownership: release from any other controller first.
+      await releaseSessionElsewhere(deps, scope.controller, sessionId);
+      const hist = (await import("../../sessions/history.js")).readHistory(
+        deps.store.jsonlPath(sessionId),
+      );
+      await scope.controller.addAttach(sessionId, cwd, name || basenameSafe(cwd), hist);
+      res = await scope.controller.switchTo(sessionId);
+    }
+  }
   if (!res) {
-    await ctx.reply("Session not found (it may have been closed).");
+    await ctx.reply("Session not found (it may have been closed).", scope.threadExtra);
     return;
   }
   await deliverSwitch(ctx, deps, res);
 }
 
+/** Stop controlling a session on every controller except `keep`. */
+async function releaseSessionElsewhere(
+  deps: BotDeps,
+  keep: import("../chat-controller.js").ChatController,
+  sessionId: string,
+): Promise<void> {
+  for (const c of deps.registry.allForumControllers()) {
+    if (c !== keep && c.findBySession(sessionId)) await c.close(sessionId);
+  }
+  for (const chatId of deps.settings.chatIds()) {
+    try {
+      const c = deps.registry.controller(chatId);
+      if (c !== keep && c.findBySession(sessionId)) await c.close(sessionId);
+    } catch {
+      /* skip */
+    }
+  }
+}
+
+function basenameSafe(p: string): string {
+  const n = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const i = n.lastIndexOf("/");
+  return i >= 0 ? n.slice(i + 1) : n;
+}
+
 export function registerRunning(bot: Bot, deps: BotDeps): void {
   bot.command("running", (ctx) => showRunning(ctx, deps));
 
@@ -140,8 +270,24 @@ export function registerRunning(bot: Bot, deps: BotDeps): void {
 
   bot.callbackQuery(new RegExp(`^run:close:${UUID}$`), async (ctx) => {
     const id = ctx.match![1]!;
-    await deps.registry.controller(ctx.chat!.id).close(id);
-    await ctx.answerCallbackQuery({ text: "Closed" });
+    const { resolveScope } = await import("../scope.js");
+    const scope = resolveScope(ctx, deps);
+    let closed = await scope.controller.close(id);
+    // Card may show a session owned by the other surface — close on owner.
+    if (!closed) {
+      const fc = deps.registry.forumControllerForSession(id);
+      if (fc) closed = await fc.close(id);
+    }
+    if (!closed) {
+      for (const chatId of deps.settings.chatIds()) {
+        const c = deps.registry.controller(chatId);
+        if (c.findBySession(id)) {
+          closed = await c.close(id);
+          break;
+        }
+      }
+    }
+    await ctx.answerCallbackQuery({ text: closed ? "Closed" : "Not found" });
     await ctx.deleteMessage().catch(() => {}); // remove just this card
   });
 }
@@ -171,6 +317,16 @@ async function deliverSwitch(ctx: Context, deps: BotDeps, res: SwitchResult): Pr
   if (!res.busy && res.rt.lastTurnSummary) {
     await ctx.reply(res.rt.lastTurnSummary);
   }
+
+  // Re-show post-turn suggestions generated while this session was in the
+  // background (or if the user missed the Done notify). Buttons stay wired to
+  // the same batch ids so taps still submit the follow-up.
+  if (!res.busy) {
+    const sug = res.rt.peekPendingSuggestions();
+    if (sug) {
+      await ctx.reply(sug.text, { reply_markup: sug.markup }).catch(() => {});
+    }
+  }
 }
 
 function fmtEntry(e: HistoryEntry): string {