grok-telegram-bot 2.3.0 → 2.4.0

package/src/bot/complexity-gate.ts

@@ -0,0 +1,69 @@
+/**
+ * First-prompt complexity steering (fully automatic — never asks the user).
+ *
+ * On the first user message of a fresh session the bot prepends a directive so
+ * Grok itself decides Simple vs Complex:
+ *   • Simple  — implement directly.
+ *   • Complex — enter plan mode, investigate carefully, write a plan,
+ *               exit_plan_mode (auto-approved by this bridge), implement,
+ *               then re-review the result.
+ *
+ * No Telegram buttons, no user choice, no waiting.
+ */
+import type { PromptInput } from "../app/types.js";
+
+/**
+ * Agent-only directive. Must stay free of real `{progress: N%}` digit markers
+ * (history cleaner strips those). Uses the letter N only if mentioning format.
+ */
+export const AUTO_COMPLEXITY_DIRECTIVE = [
+  "COMPLEXITY (decide yourself — never ask the user):",
+  "Silently classify this task as Simple or Complex. Do NOT ask the user which it is. Do NOT show Simple/Complex buttons or questions.",
+  "",
+  "If SIMPLE (clear path, small change, obvious fix, short answer):",
+  "  implement or answer directly with normal care.",
+  "",
+  "If COMPLEX (ambiguity, multi-file architecture, high rework risk, unclear approach):",
+  "  1. Enter plan mode (enter_plan_mode) when available.",
+  "  2. Investigate carefully: explore the codebase, map patterns, edge cases, and risks before coding.",
+  "  3. Write a solid plan to the plan file; prefer investigation over speed.",
+  "  4. Call exit_plan_mode when ready. This Telegram bridge auto-approves plan exit",
+  "     (there is no TUI plan popup). After exit_plan_mode succeeds, implement fully.",
+  "     Do NOT wait for the user to \"approve a popup\" — just call exit_plan_mode and proceed.",
+  "  5. After implementation, re-review your work (verify correctness, edge cases, and that the plan was followed) before finishing.",
+  "",
+  "User task:",
+].join("\n");
+
+/** Optional mode ids Grok may advertise for plan mode (best-effort only). */
+export const PLAN_MODE_CANDIDATES = ["plan", "planning", "architect", "design"] as const;
+
+/**
+ * Prepend the auto-complexity directive so the agent decides Simple vs Complex
+ * without any user interaction.
+ */
+export function wrapAutoComplexityPrompt(input: PromptInput): PromptInput {
+  const body = input.text.trim() || "(see attached media / files)";
+  // Avoid double-wrapping if a retry/queue path already applied it.
+  if (body.startsWith("COMPLEXITY (decide yourself")) return input;
+  return {
+    ...input,
+    text: `${AUTO_COMPLEXITY_DIRECTIVE}\n${body}`,
+  };
+}
+
+/** Pick a plan-mode id from the agent's advertised modes, if any. */
+export function pickPlanModeId(
+  modes: Array<{ id: string; name: string }>,
+  hasMode: (id: string) => boolean,
+): string | undefined {
+  for (const id of PLAN_MODE_CANDIDATES) {
+    if (hasMode(id)) return id;
+  }
+  for (const m of modes) {
+    if (/plan|architect|design/i.test(m.id) || /plan|architect|design/i.test(m.name)) {
+      return m.id;
+    }
+  }
+  return undefined;
+}

package/src/bot/deps.ts

@@ -10,6 +10,8 @@ import type { AppConfig } from "../config.js";
 import type { SttService } from "../app/stt.js";
 import type { UsageService } from "../app/usage.js";
 import type { ProjectEntry, ProjectManager } from "../projects/manager.js";
+import type { ImportableSession } from "../import/list-running.js";
+import type { ImportSourceId } from "../import/sources.js";
 import type { SessionMeta } from "../sessions/types.js";
 import type { SessionStore } from "../sessions/store.js";
 import type { TaskRunner } from "../tasks/runner.js";
@@ -42,6 +44,10 @@ export interface BotDeps {
 export class MenuCache {
   private readonly projectLists = new Map<number, ProjectEntry[]>();
   private readonly sessionLists = new Map<number, { metas: SessionMeta[]; heading: string }>();
+  private readonly importLists = new Map<
+    number,
+    { sourceId: ImportSourceId; sessions: ImportableSession[] }
+  >();
 
   setProjects(chatId: number, list: ProjectEntry[]): void {
     this.projectLists.set(chatId, list);
@@ -64,4 +70,17 @@ export class MenuCache {
   getSessions(chatId: number): { metas: SessionMeta[]; heading: string } | undefined {
     return this.sessionLists.get(chatId);
   }
+
+  /** Cache foreign sessions shown by Import session (callback index → session). */
+  setImportSessions(chatId: number, sourceId: ImportSourceId, sessions: ImportableSession[]): void {
+    this.importLists.set(chatId, { sourceId, sessions });
+  }
+
+  getImportSessions(chatId: number): { sourceId: ImportSourceId; sessions: ImportableSession[] } | undefined {
+    return this.importLists.get(chatId);
+  }
+
+  getImportSession(chatId: number, index: number): ImportableSession | undefined {
+    return this.importLists.get(chatId)?.sessions[index];
+  }
 }

package/src/bot/handlers/accounts.ts

@@ -11,6 +11,7 @@ import { type Bot, type Context, InlineKeyboard } from "grammy";
 import { AuthService } from "../../app/auth-service.js";
 import type { StoredAccount } from "../../app/accounts.js";
 import { UNSUPPORTED_LOGIN_HELP } from "../../app/grok-credentials.js";
+import { formatCliBillingLines } from "../../app/usage.js";
 import { createLogger } from "../../logger.js";
 import type { BotDeps } from "../deps.js";
 
@@ -48,12 +49,35 @@ async function view(deps: BotDeps, note?: string): Promise<{ text: string; keybo
   } else {
     lines.push("\u{1F7E2} Signed in (identity unknown).", "");
   }
+  // Live Grok CLI monthly quota for the host login (same source as OmniRoute-style clients).
+  if (loggedIn) {
+    const { billing, error } = await deps.usage.cliBilling().catch((e) => ({
+      billing: undefined,
+      error: (e as Error).message,
+    }));
+    if (billing) {
+      lines.push(...formatCliBillingLines(billing), "");
+    } else if (error) {
+      lines.push(`\u{1F4B3} Grok CLI quota: unavailable (${error})`, "");
+    }
+  }
   if (list.length === 0) {
     lines.push("No saved accounts yet.", "", "Save the current login below, or sign in via /reauth.");
   } else {
     for (const a of list) {
       lines.push(accountLine(a, a.id === active));
-      if (a.warning) lines.push("  \u2514 Skipped by auto-rotate after an account access or quota error.");
+      const usage = deps.accounts.formatUsageLine(a);
+      if (usage) lines.push(`  \u2514 \u{1F4CA} ${usage}`);
+      else lines.push("  \u2514 \u{1F4CA} No recorded usage yet");
+      if (a.warning) {
+        lines.push(
+          `  \u2514 \u26A0\uFE0F Skipped by auto-rotate: ${a.warning.reason.slice(0, 80)}${a.warning.reason.length > 80 ? "\u2026" : ""}`,
+        );
+      }
+    }
+    const totals = summarizeUsage(list);
+    if (totals) {
+      lines.push("", `\u{1F4CA} All saved accounts: ${totals}`);
     }
   }
   const rotate = deps.accounts.autoRotateEnabled();
@@ -86,6 +110,32 @@ function trim(s: string, n = 22): string {
   return s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 }
 
+/** Aggregate usage across saved accounts for the footer line. */
+function summarizeUsage(list: StoredAccount[]): string {
+  let turns = 0;
+  let credits = 0;
+  let used = 0;
+  for (const a of list) {
+    const u = a.usage;
+    if (!u) continue;
+    if (u.turns > 0 || u.credits > 0) used++;
+    turns += u.turns || 0;
+    credits += u.credits || 0;
+  }
+  if (used === 0 && turns === 0 && credits === 0) return "";
+  const parts: string[] = [];
+  if (turns > 0) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (credits > 0) parts.push(`${fmtNum(credits)} credits total`);
+  parts.push(`${used}/${list.length} accounts used`);
+  return parts.join(" \u00B7 ");
+}
+
+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);
+}
+
 export async function showAccounts(ctx: Context, deps: BotDeps): Promise<void> {
   const { text, keyboard } = await view(deps);
   await deps.ephemeral.open(ctx);
@@ -205,9 +255,9 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
     // Import reuses the live auth.json — just re-bind the agent headlessly.
     try {
       await deps.acp.stopAndWait();
-      await deps.acp.start();
+      await deps.acp.start(true);
     } catch (e) {
-      await deps.acp.start().catch(() => {});
+      await deps.acp.start(true).catch(() => {});
       return void rerender(ctx, deps, `\u26A0\uFE0F Imported, but re-bind failed: ${(e as Error).message}`);
     }
     let note = `\u2705 Imported the current login${res.label ? ` (${res.label})` : ""}.`;
@@ -239,9 +289,9 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
       try {
         meta = await deps.accounts.switchTo(id);
         // 3) Start agent; it authenticates headlessly with cached_token.
-        await deps.acp.start();
+        await deps.acp.start(true);
       } catch (e) {
-        await deps.acp.start().catch(() => {});
+        await deps.acp.start(true).catch(() => {});
         throw e;
       }
       const note = (await deps.usage.isLoggedIn())

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,19 @@
 /**
  * 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 { refreshMenu } from "../menu/refresh.js";
+import { showImportSources } from "./import-session.js";
 import { showKillConfirm } from "./kill.js";
 import { showMcp } from "./mcp.js";
 import { showProjects } from "./projects.js";
@@ -20,13 +23,12 @@ 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. */
 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", {
     reply_markup: mainMenuInline({
-      agent: rt.agent || "default",
       model: rt.model || "default",
       reasoning: reasoningLabel(rt.reasoning),
     }),
@@ -52,16 +54,6 @@ 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;
@@ -113,12 +105,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);
@@ -178,26 +177,6 @@ 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);
   await deps.ephemeral.open(ctx);

package/src/bot/handlers/message.ts

@@ -88,6 +88,7 @@ async function flush(deps: BotDeps, batches: Map<number, TextBatch>, chatId: num
         `\u{1F4E5} Queued (position ${rt.queueLength})${note} \u2014 I'm still working on the previous task. It'll run next.`,
       );
     }
+    // "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}`);