grok-telegram-bot 2.3.0 → 2.4.0

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

package/src/bot/handlers/usage.ts

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

package/src/bot/menu/keyboard.ts

@@ -2,8 +2,9 @@
  * Menu surfaces:
  *  - a tiny PERSISTENT bar (☰ Menu · 🧭 Running · ⏹ Stop) — minimal footprint;
  *  - a full, organized INLINE menu opened on demand (and hideable).
- * Live state (project/agent/model/reasoning/context) lives in the pinned panel,
- * so the bar stays clean.
+ * Live state (project/model/reasoning/context) lives in the pinned panel,
+ * so the bar stays clean. (Agent picker removed — Grok has no useful headless
+ * agent switch; plan mode is entered automatically when the agent judges the task complex.)
  */
 import { InlineKeyboard, Keyboard } from "grammy";
 
@@ -18,7 +19,7 @@ export function compactKeyboard(): Keyboard {
 }
 
 /** The full, grouped inline menu (opened via ☰ Menu or /menu). */
-export function mainMenuInline(state: { agent: string; model: string; reasoning: string }): InlineKeyboard {
+export function mainMenuInline(state: { model: string; reasoning: string }): InlineKeyboard {
   const t = (s: string, n: number): string => (s.length > n ? s.slice(0, n - 1) + "\u2026" : s);
   return new InlineKeyboard()
     .text("\u{1F4C1} Project", "m:project")
@@ -27,7 +28,7 @@ export function mainMenuInline(state: { agent: string; model: string; reasoning:
     .text("\u{1F9ED} Running", "m:running")
     .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
-    .text(`\u{1F916} Agent \u00B7 ${t(state.agent, 24)}`, "m:agent")
+    .text("\u{1F4E5} Import session", "m:import")
     .row()
     .text(`\u{1F9E9} Model \u00B7 ${t(state.model, 24)}`, "m:model")
     .row()

package/src/bot/menu/status-panel.ts

@@ -49,11 +49,15 @@ export class StatusPanel {
     const SEP = " | "; // pipe delimiter between inline fields
     const lines: string[] = [];
 
-    // 1) Progress first — only while a turn is live (cleared when it ends), so
-    //    the collapsed pin preview shows how far along the current task is.
+    // 1) Active plan board first (always above the progress bar) so the user
+    //    always sees done / in-progress / pending steps while a plan is live.
+    const plan = rt.planBoard;
+    if (plan) lines.push(plan);
+
+    // 2) Progress — only while a turn is live (cleared when it ends).
     if (progress !== undefined) lines.push(`\u{1F4C8} ${progressBar(progress)}`);
 
-    // 2) Activity: state + only the counters that currently apply.
+    // 3) Activity: state + only the counters that currently apply.
     const activity: string[] = [rt.isBusy ? "\u23F3 Working" : "\u2705 Idle"];
     if (rt.queueLength > 0) activity.push(`\u{1F4E5} ${rt.queueLength} queued`);
     if (running > 1) activity.push(`\u{1F9ED} ${running} sessions`);
@@ -61,13 +65,22 @@ export class StatusPanel {
     if (subagents) activity.push(`\u{1F465} ${subagents}`);
     lines.push(activity.join(SEP));
 
-    // 3) Where: project | session | context usage.
+    // 3b) What is happening now / last summary (same source as Running cards).
+    // Prefer plan one-liner over a redundant tool-step when a plan is active.
+    const comment = rt.planSummary && rt.isBusy ? undefined : rt.cardComment;
+    if (comment) {
+      const icon = rt.isBusy ? "\u23F3" : "\u{1F4AC}";
+      const shown = comment.length > 120 ? `${comment.slice(0, 119)}\u2026` : comment;
+      lines.push(`${icon} ${shown}`);
+    }
+
+    // 4) Where: project | session | context usage.
     const loc = [`\u{1F4C1} ${project}`, `\u{1F9F5} ${session}`];
     if (ctxPct !== undefined) loc.push(`\u{1F4CA} ${ctxPct.toFixed(0)}% context`);
     lines.push(loc.join(SEP));
 
-    // 4) How: agent | reasoning | model.
-    lines.push([`\u{1F916} ${s.agent || "default"}`, `\u{1F9E0} ${reasoningLabel(s.reasoning)}`, `\u{1F9E9} ${s.model || "default"}`].join(SEP));
+    // 5) How: reasoning | model (agent picker removed — plan mode is automatic).
+    lines.push([`\u{1F9E0} ${reasoningLabel(s.reasoning)}`, `\u{1F9E9} ${s.model || "default"}`].join(SEP));
 
     return lines.join("\n");
   }

package/src/bot/prompt-content.ts

@@ -66,6 +66,9 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
   const quotes = inputs
     .map((i) => i.quotedText?.trim())
     .filter((q): q is string => !!q);
+  // Preserve meta flags: auto-suggestion batches / self-recheck must not re-arm
+  // another recheck after merge (dropping this caused infinite recheck loops).
+  const skipSelfRecheck = inputs.some((i) => i.skipSelfRecheck);
   return {
     text: inputs
       .map((i) => i.text)
@@ -75,6 +78,7 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
     resourceLinks: inputs.flatMap((i) => i.resourceLinks ?? []),
     replyTo: inputs.find((i) => i.replyTo !== undefined)?.replyTo,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
+    skipSelfRecheck: skipSelfRecheck || undefined,
   };
 }
 

package/src/bot/reauth-controller.ts

@@ -180,7 +180,7 @@ export class ReauthController {
       }
       s.phase = "restarting";
       await this.render(s);
-      await this.grok.start();
+      await this.grok.start(true);
       agentDown = false;
       s.accountLabel = accountLabel(await this.getAccount?.().catch(() => undefined));
       s.phase = "done";
@@ -191,7 +191,7 @@ export class ReauthController {
     } finally {
       s.abort = undefined;
       this.stopAnim(s);
-      if (agentDown) await this.grok.start().catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
+      if (agentDown) await this.grok.start(true).catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
       await this.render(s);
     }
   }

package/src/bot/session-fork.ts

@@ -33,3 +33,14 @@ export function buildPriming(transcript: string): string {
     "=== END TRANSCRIPT ===",
   ].join("\n");
 }
+
+/**
+ * First-turn prompt body used after a foreign-session import. The heavy
+ * transcript lives in {@link SessionRuntime}'s primingContext; this is the
+ * short user message that flushes priming into the live Grok session.
+ */
+export const IMPORT_CONFIRM_PROMPT =
+  "Session import complete. Confirm you have the full imported context " +
+  "(read the transcript file if anything was truncated inline). " +
+  "Reply with a one-line ready confirmation: project path + one-sentence " +
+  "summary of the task so far. Do not continue work until I send the next message.";