grok-telegram-bot 2.3.1 → 2.4.0

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);

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}`);

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, readLastCardSummary } from "../../sessions/history.js";
 import { progressBar } from "../../render/progress.js";
 import { refreshMenu } from "../menu/refresh.js";
 import { sendMarkdownDoc } from "../telegram-io.js";
@@ -49,27 +49,47 @@ 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.
+ *
+ *  The comment line always answers "what is happening / what was solved":
+ *    busy  → live current step (tool / thinking / working on …)
+ *    idle  → last-turn outcome (assistant result + files), never bare import noise
+ */
 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 historySummary = "";
+  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));
+    // Last assistant outcome beats first-prompt import-confirm noise.
+    historySummary = readLastCardSummary(path);
+    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 comment → persisted last-turn summary → history tail → first prompt.
+  const comment =
+    (s.comment && s.comment.trim()) ||
+    diskComment ||
+    historySummary ||
+    firstPrompt;
+
   const meta = [when, state];
   if (s.busy) meta.push("\u23F3");
   if (s.unread > 0) meta.push(`${s.unread} \u{1F4EC} unread`);
 
+  const commentLabel = s.busy ? "\u23F3" : "\u{1F4AC}";
   const lines = [
     `${dot} ${s.projectName}`,
-    prompt ? `\u{1F4AC} \u201C${trunc(prompt, 120)}\u201D` : "\u{1F4AC} (no messages yet)",
+    comment
+      ? `${commentLabel} ${trunc(comment, 200)}`
+      : "\u{1F4AC} (no messages yet)",
     `\u{1F552} ${meta.join(" \u00B7 ")}`,
   ];
   if (s.progress !== undefined) lines.push(`\u{1F4C8} ${progressBar(s.progress)}`);
@@ -171,6 +191,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 {

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;
+  /**
+   * Live step (while working) or chat summary (when idle). Overrides
+   * `m.comment` when provided by the controlling chat runtime.
+   */
+  comment?: string;
 }
 
 export interface SessionCard {
@@ -34,9 +40,15 @@ export function buildSessionCard(m: SessionMeta, extra: SessionCardExtras = {}):
   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}`);
+  // Always surface "what is happening / what was done" when we have it.
+  if (comment) {
+    const icon = m.active || typeof extra.progress === "number" ? "\u23F3" : "\u{1F4AC}";
+    lines.push(`${icon} ${comment.length > 160 ? comment.slice(0, 159) + "\u2026" : comment}`);
+  }
   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, readLastCardSummary } from "../../sessions/history.js";
 import type { SessionMeta } from "../../sessions/types.js";
 import { refreshMenu } from "../menu/refresh.js";
 import { showHistory } from "./history.js";
@@ -52,8 +52,19 @@ async function renderSessionPage(ctx: Context, deps: BotDeps, page: number): Pro
 
   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 = deps.registry.controller(ctx.chat!.id);
+    const progress = ctrl.progressFor(m.sessionId);
+    // Live runtime → persisted comment → last assistant outcome from history.
+    const comment =
+      ctrl.commentFor(m.sessionId) ||
+      m.comment ||
+      readLastCardSummary(deps.store.jsonlPath(m.sessionId));
+    const { text, keyboard } = buildSessionCard(m, {
+      contextPct,
+      selfPid: deps.acp.pid,
+      progress,
+      comment,
+    });
     await deps.ephemeral.reply(ctx, text, { reply_markup: keyboard });
   }