grok-telegram-bot 2.3.1 → 2.5.0

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

@@ -0,0 +1,290 @@
+/**
+ * Import session — pick a sibling bot (Kiro / OpenCode / Claude / Codex), list
+ * its /running (controlled) sessions, and import one into this chat as a new
+ * Grok session primed with the full transcript (nothing lost).
+ *
+ * Flow:
+ *   Menu → Import session → source → running session cards → Import
+ */
+import { basename, join } from "node:path";
+import { type Bot, type Context, InlineKeyboard } from "grammy";
+import { textPrompt } from "../../app/types.js";
+import { buildImportPackage } from "../../import/build-import.js";
+import { listRunningFromSource, type ImportableSession } from "../../import/list-running.js";
+import {
+  getImportSource,
+  IMPORT_SOURCES,
+  sourceAvailable,
+  type ImportSourceId,
+} from "../../import/sources.js";
+import { createLogger } from "../../logger.js";
+import type { BotDeps } from "../deps.js";
+import { IMPORT_CONFIRM_PROMPT } from "../session-fork.js";
+import { refreshMenu } from "../menu/refresh.js";
+
+const log = createLogger("import-session");
+
+const CARD_LIMIT = 20;
+
+/** Open the source picker (menu entry / /import). */
+export async function showImportSources(ctx: Context, deps: BotDeps): Promise<void> {
+  await deps.ephemeral.open(ctx);
+  const kb = new InlineKeyboard();
+  for (const src of IMPORT_SOURCES) {
+    const ok = sourceAvailable(src);
+    const mark = ok ? "" : " \u26A0";
+    kb.text(`${labelEmoji(src.id)} ${src.label}${mark}`, `imp:src:${src.id}`).row();
+  }
+  kb.text("\u2716 Cancel", "imp:cancel");
+  await deps.ephemeral.reply(
+    ctx,
+    [
+      "\u{1F4E5} Import session",
+      "",
+      "Choose the source tool. You will then see its /running sessions",
+      "and can import one into Grok with full conversation context.",
+    ].join("\n"),
+    { reply_markup: kb },
+  );
+}
+
+/** List /running sessions for a source bot. */
+export async function showImportRunning(
+  ctx: Context,
+  deps: BotDeps,
+  sourceId: ImportSourceId,
+): Promise<void> {
+  const src = getImportSource(sourceId);
+  if (!src) {
+    await ctx.reply("Unknown source.");
+    return;
+  }
+  await deps.ephemeral.open(ctx);
+
+  if (!sourceAvailable(src)) {
+    await deps.ephemeral.reply(
+      ctx,
+      `\u26A0\uFE0F ${src.label} bot root not found:\n\`${src.botRoot}\``,
+    );
+    return;
+  }
+
+  const chatId = ctx.chat!.id;
+  let sessions = listRunningFromSource(src, chatId);
+  // If this Telegram chat id has no controlled sessions there, union all chats
+  // on that bot (same human often uses one chat id everywhere).
+  if (sessions.length === 0) sessions = listRunningFromSource(src);
+
+  if (sessions.length === 0) {
+    const kb = new InlineKeyboard().text("\u25C0 Sources", "imp:back").text("\u2716 Cancel", "imp:cancel");
+    await deps.ephemeral.reply(
+      ctx,
+      [
+        `\u{1F4E5} ${src.label} \u2014 no /running sessions`,
+        "",
+        "That bot has no controlled sessions in its settings right now.",
+        "Open a session there first (Project / message), then try Import again.",
+      ].join("\n"),
+      { reply_markup: kb },
+    );
+    return;
+  }
+
+  deps.menuCache.setImportSessions(chatId, sourceId, sessions);
+  const shown = sessions.slice(0, CARD_LIMIT);
+  await deps.ephemeral.reply(
+    ctx,
+    `\u{1F4E5} ${src.label} /running \u2014 ${sessions.length} session(s). Tap Import on a card:`,
+  );
+
+  const now = Date.now();
+  for (let i = 0; i < shown.length; i++) {
+    const s = shown[i]!;
+    const { text, kb } = buildImportCard(s, i, now);
+    await deps.ephemeral.reply(ctx, text, { reply_markup: kb });
+  }
+  if (sessions.length > shown.length) {
+    await deps.ephemeral.reply(ctx, `\u2026and ${sessions.length - shown.length} more (not shown).`);
+  }
+  const nav = new InlineKeyboard().text("\u25C0 Sources", "imp:back").text("\u2716 Cancel", "imp:cancel");
+  await deps.ephemeral.reply(ctx, "Pick a session above, or go back.", { reply_markup: nav });
+}
+
+/** Perform the import into a new Grok /running session. */
+export async function doImportSession(ctx: Context, deps: BotDeps, index: number): Promise<void> {
+  const chatId = ctx.chat!.id;
+  const cached = deps.menuCache.getImportSessions(chatId);
+  const session = cached?.sessions[index];
+  if (!session || !cached) {
+    await ctx.reply("That import list expired \u2014 open Import session again.");
+    return;
+  }
+  const src = getImportSource(cached.sourceId);
+  if (!src) {
+    await ctx.reply("Unknown source.");
+    return;
+  }
+
+  await deps.ephemeral.clear(chatId).catch(() => {});
+  await ctx.reply(
+    `\u23F3 Importing from ${src.label} \u2026\n\`${session.sessionId.slice(0, 12)}\` \u00B7 ${session.projectName ?? (basename(session.cwd || "") || "project")}`,
+  );
+
+  const cwd = resolveImportCwd(session, deps, chatId);
+  const projectName = session.projectName || (cwd ? basename(cwd) : "imported");
+  const importsDir = join(deps.cfg.dataDir, "imports");
+
+  let pkg;
+  try {
+    pkg = buildImportPackage(src, { ...session, cwd }, importsDir);
+  } catch (e) {
+    log.error("buildImportPackage failed:", (e as Error).message);
+    await ctx.reply(`\u274C Could not read source history: ${(e as Error).message}`);
+    return;
+  }
+
+  if (pkg.entryCount === 0) {
+    await ctx.reply(
+      [
+        `\u26A0\uFE0F No history entries found on disk for this session.`,
+        `Session id: \`${session.sessionId}\``,
+        `I will still open a Grok session in the project, but context may be empty.`,
+        `Transcript archive: \`${pkg.transcriptPath}\``,
+      ].join("\n"),
+    );
+  }
+
+  try {
+    const rt = await deps.registry.controller(chatId).addImport(cwd, projectName, pkg.priming);
+    // Flush priming into the live Grok session immediately so context is not
+    // waiting on the user's next free-form message.
+    void rt.submit(textPrompt(IMPORT_CONFIRM_PROMPT));
+
+    const lines = [
+      `\u2705 Imported into Grok /running`,
+      `\u{1F4E5} ${src.label} \u2192 Grok`,
+      `\u{1F4C1} ${projectName}`,
+      cwd ? `   ${cwd}` : "",
+      `\u{1F4DC} ${pkg.entryCount} history entries \u00B7 ${humanSize(pkg.transcriptChars)} transcript`,
+      pkg.truncatedInline
+        ? `\u2139\uFE0F Full transcript is on disk (inline slice was capped); Grok will use the file if needed.`
+        : `\u2705 Full transcript inlined into the first Grok turn.`,
+      `\u{1F4C4} ${pkg.transcriptPath}`,
+      rt.sessionId ? `\u{1F194} new Grok session ${rt.sessionId.slice(0, 8)}` : "",
+      ``,
+      `Grok is loading the context now. After the short confirmation, send your next instruction to continue.`,
+    ].filter(Boolean);
+
+    await refreshMenu(ctx, deps, `\u{1F4E5} Imported ${src.label} \u00B7 ${projectName}`);
+    await ctx.reply(lines.join("\n"));
+  } catch (e) {
+    log.error("import failed:", (e as Error).message);
+    await ctx.reply(
+      `\u274C Import failed: ${(e as Error).message}\nTranscript (if written): \`${pkg.transcriptPath}\``,
+    );
+  }
+}
+
+export function registerImportSession(bot: Bot, deps: BotDeps): void {
+  bot.command("import", (ctx) => showImportSources(ctx, deps));
+
+  bot.callbackQuery("imp:cancel", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await ctx.deleteMessage().catch(() => {});
+  });
+
+  bot.callbackQuery("imp:back", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await deps.ephemeral.clear(ctx.chat!.id).catch(() => {});
+    await showImportSources(ctx, deps);
+  });
+
+  bot.callbackQuery(/^imp:src:(kiro|opencode|claude|codex)$/, async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await deps.ephemeral.clear(ctx.chat!.id).catch(() => {});
+    await showImportRunning(ctx, deps, ctx.match![1] as ImportSourceId);
+  });
+
+  bot.callbackQuery(/^imp:go:(\d+)$/, async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Importing\u2026" });
+    await doImportSession(ctx, deps, Number(ctx.match![1]));
+  });
+}
+
+// ── cards / helpers ──────────────────────────────────────────────────────────
+
+function buildImportCard(
+  s: ImportableSession,
+  index: number,
+  now: number,
+): { text: string; kb: InlineKeyboard } {
+  const proj = s.projectName || (s.cwd ? basename(s.cwd) : "(no project)");
+  const when = s.updatedAt ? timeAgo(now - Date.parse(s.updatedAt)) : "unknown";
+  const title = cleanTitle(s.title);
+  const hist =
+    s.historyBytes > 0 ? humanSize(s.historyBytes) : s.historyPath ? "0 B" : "no history file";
+
+  const lines = [
+    `\u{1F4E5} ${proj}`,
+    title ? `\u{1F4AC} \u201C${trunc(title, 120)}\u201D` : "\u{1F4AC} (no title)",
+    s.cwd ? `\u{1F4C1} ${s.cwd}` : "\u{1F4C1} (no cwd recorded)",
+    `\u{1F552} ${when} \u00B7 \u{1F4DC} ${hist}`,
+    `\u{1F194} ${s.sessionId.length > 16 ? s.sessionId.slice(0, 12) + "\u2026" : s.sessionId}`,
+  ];
+
+  const kb = new InlineKeyboard().text("\u{1F4E5} Import into Grok", `imp:go:${index}`);
+  return { text: lines.join("\n"), kb };
+}
+
+function resolveImportCwd(session: ImportableSession, deps: BotDeps, chatId: number): string {
+  if (session.cwd) return session.cwd;
+  // No cwd on the source session — stay on this chat's current project.
+  try {
+    return deps.registry.get(chatId).cwd || deps.cfg.workspace;
+  } catch {
+    return deps.cfg.workspace;
+  }
+}
+
+function labelEmoji(id: ImportSourceId): string {
+  switch (id) {
+    case "kiro":
+      return "\u{1F3AF}";
+    case "opencode":
+      return "\u26A1";
+    case "claude":
+      return "\u{1F9E0}";
+    case "codex":
+      return "\u{1F4D6}";
+  }
+}
+
+function cleanTitle(raw: string): string {
+  let t = (raw || "").trim().replace(/^\([^)]*\)\s*/, "");
+  const marker = "User's new message:";
+  const i = t.lastIndexOf(marker);
+  if (i !== -1) t = t.slice(i + marker.length);
+  return t.replace(/\s+/g, " ").trim();
+}
+
+function trunc(s: string, n: number): string {
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
+
+function timeAgo(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 0) return "unknown";
+  const s = Math.round(ms / 1000);
+  if (s < 45) return "just now";
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.round(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.round(h / 24)}d ago`;
+}
+
+function humanSize(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/bot/handlers/menu.ts

@@ -1,16 +1,28 @@
 /**
  * Menu handler — maps the persistent reply-keyboard buttons (matched by emoji
- * prefix for stateful ones) to actions, and provides inline submenus for Agent
- * (real Grok modes), Reasoning, and Model. Changing a value re-renders the
- * keyboard so its labels always reflect the current state.
+ * prefix for stateful ones) to actions, and provides inline submenus for
+ * Reasoning and Model. Changing a value re-renders the keyboard so its labels
+ * always reflect the current state.
+ *
+ * The Agent picker was removed: Grok has no useful headless agent switch, and
+ * plan mode is entered automatically when the agent judges a task complex.
  */
 import { type Bot, type Context, InlineKeyboard } from "grammy";
 import { reasoningLabel } from "../../app/reasoning.js";
-import { listAgents } from "../../agents/catalog.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";
 import { showProjects } from "./projects.js";
@@ -20,15 +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 agent/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({
-      agent: rt.agent || "default",
-      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,
     }),
   });
 }
@@ -37,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,
+        );
       }
     }
   });
@@ -52,20 +87,10 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
   // Inline menu actions.
   bot.callbackQuery(/^m:(\w+)$/, (ctx) => dispatchMenu(ctx, deps, ctx.match![1]!));
 
-  // ── Agent (real Grok modes) ─────────────────────────────────────────────
-  bot.callbackQuery(/^agent:set:(\d+)$/, async (ctx) => {
-    const mode = deps.acp.availableModes[Number(ctx.match![1])];
-    if (!mode) return void ctx.answerCallbackQuery({ text: "Expired, tap Agent again." });
-    // Answer before ACP so a slow setMode never expires the callback query.
-    await ctx.answerCallbackQuery({ text: `\u{1F916} Agent: ${mode.name}` });
-    await deps.registry.get(ctx.chat!.id).setAgentPref(mode.id);
-    await confirmUi(ctx, deps);
-  });
-
   // ── 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)}`);
   });
 
@@ -74,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":
@@ -113,12 +153,19 @@ async function dispatchMenu(ctx: Context, deps: BotDeps, action: string): Promis
     case "sessions":
       await ctx.answerCallbackQuery();
       return showSessions(ctx, deps);
+    case "import":
+      await ctx.answerCallbackQuery();
+      return showImportSources(ctx, deps);
     case "tasks":
       await ctx.answerCallbackQuery();
       return showTasks(ctx, deps);
     case "agent":
-      await ctx.answerCallbackQuery();
-      return showAgentMenu(ctx, deps);
+      // Legacy callback from old keyboards.
+      await ctx.answerCallbackQuery({
+        text: "Agent menu removed — Grok picks sub-agents automatically",
+        show_alert: true,
+      });
+      return openMainMenu(ctx, deps);
     case "model":
       await ctx.answerCallbackQuery();
       return showModelMenu(ctx, deps);
@@ -143,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,41 +234,26 @@ async function confirmUi(ctx: Context, deps: BotDeps): Promise<void> {
   await openMainMenu(ctx, deps); // reopen so the new value is visible
 }
 
-async function showAgentMenu(ctx: Context, deps: BotDeps): Promise<void> {
-  const rt = deps.registry.get(ctx.chat!.id);
-  await ensureReady(ctx, rt);
-  await deps.ephemeral.open(ctx);
-  const modes = deps.acp.availableModes.slice(0, 60);
-  if (modes.length === 0) {
-    // Grok has no headless agent switch; surface the sub-agents it can delegate
-    // to (built-ins + any custom ones in ~/.grok/user-settings.json) as info.
-    const subs = listAgents(rt.cwd).map((s) => s.name);
-    const info = subs.length
-      ? `Grok sub-agents available: ${subs.join(", ")}.\nGrok delegates to these automatically during a turn (via its task/delegate tools) — there's no headless agent switch. Use \u{1F9E9} Model to change the model.`
-      : "Grok delegates to built-in sub-agents automatically in headless mode; there's no agent to select. Use \u{1F9E9} Model to change the model.";
-    await deps.ephemeral.reply(ctx, `Current agent: ${rt.agent || "default"}\n${info}`);
-    return;
-  }
-  const kb = new InlineKeyboard();
-  modes.forEach((m, i) => kb.text(`${m.id === rt.agent ? "\u2713 " : ""}${m.name}`, `agent:set:${i}`).row());
-  await deps.ephemeral.reply(ctx, `Current agent: ${rt.agent || "default"}\nChoose an agent:`, { reply_markup: kb });
-}
-
 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;