grok-telegram-bot 2.2.0 → 2.2.2

package/CHANGELOG.md

@@ -9,6 +9,35 @@ The latest section is published verbatim as the GitHub Release notes by
 
 ## [Unreleased]
 
+## [2.2.2] - 2026-07-12
+
+Patch release that hardens multi-account identity and documents the full **2.2.x**
+batch (headless rotation, session auto-approve, pinned permission prompts).
+
+### Fixed
+
+- **📧 Real account emails from `auth.json`.** Modern Grok access tokens often
+  omit the `email` claim; the bot now prefers `email` / `first_name` /
+  `last_name` written on the auth entry by `grok login`, then falls back to JWT
+  claims. `/accounts` and `/usage` show the host login correctly again.
+- **🪪 Active account = live token hash.** The marked `activeId` is no longer
+  trusted when the host login changed outside the menu (`grok login` / `/reauth`).
+  Saving never overwrites a different saved account; mismatch is shown in the
+  `/accounts` UI (“Host Grok login” vs saved).
+
+### Docs
+
+- README: headless account switch, device-code `/reauth`, auto-approve + pinned
+  permission prompts, `AUTO_APPROVE_PERMISSIONS`.
+
+## [2.2.1] - 2026-07-12
+
+### Fixed
+
+- **📌 Permission prompts stay pinned** while waiting for Approve/Deny so they
+  aren't lost under streaming chat. The pin is removed on approve, deny, or
+  timeout, and the status panel is re-pinned afterwards.
+
 ## [2.2.0] - 2026-07-12
 
 The **reliable multi-account** release — account switch / auto-rotate now only
@@ -669,6 +698,8 @@ from a single chat and switch between them, on a redesigned, compact menu.
   diffs, MarkdownV2 rendering, scheduled tasks, multi-image prompts, and a
   cross-platform 24/7 background service.
 
+[2.2.2]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.2
+[2.2.1]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.1
 [2.2.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.0
 [2.1.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.1.0
 [2.0.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.0.0

package/README.md

@@ -38,9 +38,10 @@ re-architected for the Grok Build CLI and extended into a full multi-session cli
 | 🧩 **MCP control** | `/mcp` lists MCP servers, **health-checks** them (which connected / failed and why), and **enables/disables** them — then restarts the agent to apply. |
 | 👥 **Subagent visibility** | When Grok delegates to subagents and waits on them, you see each one **start / work / finish** plus a live `🤖 N running` summary — and subagent permission prompts route to your chat. |
 | 📈 **Task progress bar** | The agent appends a `{progress: N%}` marker; the bot hides it and shows a **green 0–100% loading bar** on the live message, in the status panel, and on session cards (`SHOW_PROGRESS`). |
-| 🔐 **Sign in from chat** | `/reauth` signs you in without a terminal — **🔑 Sign in** runs `grok login` (any verification link/code streams to your chat), or **📥 Import** an existing on-host login; the agent restarts under the new identity. |
-| 👥 **Multiple accounts** | `/accounts` saves several Grok **sign-ins** (custom names) and switches between them in a tap — copies that login back over `~/.grok/auth.json` and restarts so sessions re-bind under the new account. |
-| 🔁 **Auto-rotate on give-up** | When a turn exhausts its retries, optionally cycle through your other saved accounts once and retry on each — the first that works wins (toggle in `/accounts`). |
+| 🔐 **Sign in from chat** | `/reauth` signs you in without a terminal — **🔑 Sign in** runs headless `grok login --device-auth` (link/code streams to your chat, no host browser), or **📥 Import** an existing on-host login; the agent restarts under the new identity. |
+| 👥 **Multiple accounts** | `/accounts` saves several Grok **sign-ins** (custom names) and switches between them in a tap — **stops the agent → replaces `~/.grok/auth.json` → restarts headlessly** (never opens a browser). |
+| 🔁 **Auto-rotate on give-up** | When a turn exhausts its retries, optionally cycle through your other saved accounts once and retry on each — the first that works wins (toggle in `/accounts`). Same headless auth.json swap. |
+| ✅ **Auto-approve tools** | By default, ACP permission prompts are auto-approved for the **session** (`AUTO_APPROVE_PERMISSIONS`). Turn both that and `GROK_TRUST_ALL_TOOLS` off for interactive Approve/Deny — those prompts are **pinned** until you act. |
 | 🪙 **Credits & usage** | The `✅ Done` line and `/usage` show credits used (when Grok reports them), turns this session, and account info. |
 | ⌨️ **Typing indicator** | Stays on for the whole turn, even through long tool chains. |
 | 📥 **Queued follow-ups** | Message while Grok is busy — it's queued and runs next. `/btw` runs it ASAP (now if idle, else right after the current task); `/flush` runs the queue now. |
@@ -62,9 +63,10 @@ re-architected for the Grok Build CLI and extended into a full multi-session cli
 | Attach to **live** PC sessions (watch / fork) | ✅ | ❌ |
 | **Kill a session by PID** (or all at once) | ✅ | ❌ |
 | **Live task-progress bars** (`{progress: N%}`) | ✅ | ❌ |
-| **Sign in from chat** (`/reauth`) | ✅ | ❌ |
-| **Multiple saved accounts** + one-tap switch (`/accounts`) | ✅ | ❌ |
+| **Sign in from chat** (`/reauth`, device-code) | ✅ | ❌ |
+| **Multiple saved accounts** + headless one-tap switch (`/accounts`) | ✅ | ❌ |
 | **Auto-rotate accounts** when a turn gives up | ✅ | ❌ |
+| **Session auto-approve** + **pinned** interactive permissions | ✅ | ❌ |
 | Multiple isolated sessions | ✅ | ❌ (single shared) |
 | Queued follow-ups while busy | ✅ | ❌ |
 | **Scheduled tasks** (cron-like) | ✅ | ❌ |
@@ -326,9 +328,10 @@ takes precedence and the value never decreases. Disable the fallback with
 Grok Build signs in with your **xAI account** (SuperGrok / X Premium+), not an
 API key. Run **`/reauth`** to sign in without touching a terminal:
 
-- **🔑 Sign in** — runs `grok login`; if a verification link/code appears it
-  streams into the chat so you can approve it on any device. The bot then
-  restarts the agent so your next turn runs on the new identity.
+- **🔑 Sign in** — runs `grok login --device-auth` (device code, **no browser on
+  the host**). The verification link/code streams into the chat so you can
+  approve it on any device. The bot then restarts the agent under the new
+  identity.
 - **📥 Import existing** — adopt a `grok login` already done on this machine
   (`~/.grok/auth.json`).
 
@@ -338,16 +341,24 @@ It's refused while a turn is running. You can also sign in up front by running
 ## 👥 Multiple accounts
 
 **`/accounts`** manages several Grok **sign-ins** side by side. Save the current
-login as a named account (auto-named from its email, or **Save as…** with a
-custom name), rename or delete saved ones, and **switch** in a tap — the bot
-copies that account's token back over `~/.grok/auth.json` and restarts the agent
-so your next turn runs under it (the current login is snapshotted first so it's
-never lost). Snapshots live only in git-ignored per-account files.
+login as a named account (auto-named from its email when available, or
+**Save as…** with a custom name), rename or delete saved ones, and **switch** in
+a tap. Switching is deliberately headless:
+
+1. Snapshot the current login (so it isn't lost),
+2. **Stop** the shared agent,
+3. **Replace** `~/.grok/auth.json` with the saved snapshot,
+4. **Start** the agent and authenticate with `cached_token` only — never a
+   browser method like `grok.com` (which would hang a service host).
+
+The menu shows the **host Grok login** vs which saved account it matches, so a
+manual `grok login` outside the bot doesn't leave a stale “active” label.
 
 **🔁 Auto-rotate on errors** (toggle here): when a turn exhausts its retries and
-can't recover, the bot cycles through your other saved logins **once**, retrying
-the prompt on each — the first that succeeds stays active; if they all fail it
-stops after one pass. Handy when an account gets throttled or runs out of quota.
+can't recover, the bot cycles through your other saved logins **once** with the
+same stop → auth.json → start path — the first that succeeds stays active; if
+they all fail it stops after one pass. Handy when an account gets throttled or
+runs out of quota.
 
 ---
 
@@ -390,7 +401,8 @@ Resuming an **idle** session loads it directly so you continue the exact thread.
 | `GROK_MODEL` | no | `grok-4.5` | Default model for new sessions. |
 | `GROK_TG_DIR` | no | `~/.grok/tg` | Folder holding this instance's `.env`, `logs/`, `data/`. Resolution: `--instance` → `GROK_TG_DIR` → a `.env` in the current folder → `~/.grok/tg`. So a `.env` created once is loaded from any startup path. |
 | `GROK_AGENT` | no | — | Custom sub-agent name (informational; Grok delegates via its own `task`/`delegate` tools). |
-| `GROK_TRUST_ALL_TOOLS` | no | `true` | Run tools without prompts. |
+| `GROK_TRUST_ALL_TOOLS` | no | `true` | Pass `--always-approve` so tools run without prompts. |
+| `AUTO_APPROVE_PERMISSIONS` | no | `true` | Auto-approve ACP `session/request_permission` (prefer “allow for this session”). Set `false` **and** `GROK_TRUST_ALL_TOOLS=false` for interactive Approve/Deny buttons (those prompts are **pinned** until you act or they time out). |
 | `PROJECT_ROOTS` | no | workspace parent + home | Roots for `/projects`. |
 | `STREAM_THROTTLE_MS` | no | `1500` | Live-edit interval while streaming. |
 | `MESSAGE_BATCH_MS` | no | `800` | Window to coalesce rapid text messages (e.g. a long message Telegram split at 4096 chars) into one prompt. `0` disables. |
@@ -486,13 +498,20 @@ the bot inherits whatever MCP servers Grok CLI is configured with.
 
 ## 🔐 Tool approvals
 
-Over ACP, Grok honors a permission mode. With `GROK_TRUST_ALL_TOOLS=true`
-(default) the bot passes `--always-approve`, so tools run without prompts. Set it
-to `false` to run in ACP **"ask"** mode: Grok sends `session/request_permission`
-before risky tools (file writes, shell commands) and the bot surfaces
-**Approve / Approve always / Deny** buttons in Telegram, sending your choice back
-(unanswered prompts eventually cancel). You can also intervene on any live turn
-with the tool stream + **⏹ Stop** (`/cancel`), which cancels that session's turn.
+Over ACP, Grok honors a permission mode. Defaults are built for unattended
+mobile use:
+
+| Setting | Default | Effect |
+|---|---|---|
+| `GROK_TRUST_ALL_TOOLS` | `true` | Passes `--always-approve` so tools run without prompts. |
+| `AUTO_APPROVE_PERMISSIONS` | `true` | If a permission request still arrives, auto-pick **allow for this session** / always-allow. |
+
+Set **both** to `false` for ACP **"ask"** mode: Grok sends
+`session/request_permission` before risky tools and the bot surfaces
+**Approve / Allow for session / Deny** buttons. Those prompts are **pinned** so
+they aren't buried by streaming output; the pin is removed when you choose,
+or when the request times out (status panel is re-pinned). You can always
+intervene on a live turn with the tool stream + **⏹ Stop** (`/cancel`).
 
 ## 🔐 Security
 
@@ -514,10 +533,11 @@ user. See [SECURITY.md](./SECURITY.md) for the full model.
 - [x] Voice messages → speech-to-text → prompt (multi-language)
 - [x] Context-usage % in the status panel
 - [x] Inline approvals — approve/deny risky tools from buttons (non trust-all mode)
+- [x] Session auto-approve + pinned permission prompts
 - [x] Account & context usage (`/usage`)
-- [x] Multiple accounts with one-tap switch + auto-rotate on errors (`/accounts`)
-- [x] Organization / Import-from-Grok-IDE login + credits on the Done line
-- [x] Release automation — downloadable zip + CHANGELOG-driven notes on tag push
+- [x] Multiple accounts with headless one-tap switch + auto-rotate (`/accounts`)
+- [x] Device-code `/reauth` (no host browser) + real email labels from auth.json
+- [x] Rich per-kind tool-call detail (search / edit diffs / shell / MCP / …)
 - [x] README community sections — Contributors, Top Contributors, Stars, StarMapper
 - [ ] **Token & cost meter** — per-session token counts and an estimated spend tally
 - [ ] **Text-to-speech replies** — optionally speak answers back as voice notes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Control the official Grok Build CLI from Telegram over the Agent Client Protocol (ACP). Sign in with your xAI account, switch projects, resume sessions, stream responses with diffs, queue follow-ups, manage multiple sign-ins, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",

package/scripts/{_release-version.mjs → _push-main-release.mjs}

@@ -1,6 +1,6 @@
 /**
- * Bump package.json on main + create vX.Y.Z tag via the GitHub API
- * (local git push/commit is restricted in this environment).
+ * Push current working-tree release files to main + create annotated tag.
+ * (Local git push is restricted in this environment.)
  */
 import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
@@ -8,9 +8,22 @@ import { spawnSync } from "node:child_process";
 const owner = "artickc";
 const repo = "grok-telegram-bot";
 const branch = "main";
-const version = "2.2.0";
+const version = "2.2.2";
 const tag = `v${version}`;
-const message = `v${version} — headless account rotation + auto-approve session permissions`;
+const message = "release: v2.2.2 — account identity, docs, 2.2.x multi-account batch";
+const tagMessage =
+  "v2.2.2 — multi-account headless rotation, session auto-approve, pinned permissions, account identity";
+
+const files = [
+  ".gitignore",
+  "CHANGELOG.md",
+  "README.md",
+  "package.json",
+  "src/app/accounts.ts",
+  "src/app/grok-credentials.ts",
+  "src/bot/handlers/accounts.ts",
+  "test/credentials.test.ts",
+];
 
 // eslint-disable-next-line no-control-regex
 const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
@@ -42,34 +55,35 @@ const baseCommit = ghApi("GET", `repos/${owner}/${repo}/git/commits/${baseSha}`)
 const baseTree = baseCommit.tree.sha;
 console.log("base", baseSha);
 
-const content = readFileSync("package.json", "utf8");
-const blob = ghApi("POST", `repos/${owner}/${repo}/git/blobs`, {
-  content: Buffer.from(content, "utf8").toString("base64"),
-  encoding: "base64",
-});
+const tree = [];
+for (const path of files) {
+  const content = readFileSync(path, "utf8");
+  const blob = ghApi("POST", `repos/${owner}/${repo}/git/blobs`, {
+    content: Buffer.from(content, "utf8").toString("base64"),
+    encoding: "base64",
+  });
+  tree.push({ path, mode: "100644", type: "blob", sha: blob.sha });
+  console.log("blob", path, blob.sha.slice(0, 8));
+}
 
 const newTree = ghApi("POST", `repos/${owner}/${repo}/git/trees`, {
   base_tree: baseTree,
-  tree: [{ path: "package.json", mode: "100644", type: "blob", sha: blob.sha }],
+  tree,
 });
-
 const commit = ghApi("POST", `repos/${owner}/${repo}/git/commits`, {
   message,
   tree: newTree.sha,
   parents: [baseSha],
 });
-console.log("commit", commit.sha);
-
 ghApi("PATCH", `repos/${owner}/${repo}/git/refs/heads/${branch}`, {
   sha: commit.sha,
   force: false,
 });
-console.log("updated", branch, "->", commit.sha);
+console.log("main ->", commit.sha);
 
-// Annotated tag for release workflow.
 const tagObj = ghApi("POST", `repos/${owner}/${repo}/git/tags`, {
   tag,
-  message: message,
+  message: tagMessage,
   object: commit.sha,
   type: "commit",
   tagger: {
@@ -78,10 +92,8 @@ const tagObj = ghApi("POST", `repos/${owner}/${repo}/git/tags`, {
     date: new Date().toISOString(),
   },
 });
-console.log("tag object", tagObj.sha);
-
 ghApi("POST", `repos/${owner}/${repo}/git/refs`, {
   ref: `refs/tags/${tag}`,
   sha: tagObj.sha,
 });
-console.log("created tag", tag);
+console.log("tag", tag, "->", commit.sha);

package/src/app/accounts.ts

@@ -76,17 +76,44 @@ export class AccountManager {
   }
 
   /**
-   * Id of the currently active saved account. Prefers the last switch target
-   * (`activeId`), then falls back to matching the live auth.json token hash.
+   * Id of the saved account that matches the live auth.json (if any).
+   * Token hash is authoritative — never trust a stale `activeId` when the host
+   * login has changed (e.g. `grok login` / /reauth outside this menu).
    */
   activeAccountId(): string | undefined {
     const data = this.store.get();
+    const lid = loginId();
+    if (lid) {
+      const byToken = data.accounts.find((a) => a.loginId === lid);
+      if (byToken) return byToken.id;
+      // Live login differs from every saved account (and any stale activeId).
+      return undefined;
+    }
+    // No readable token (API-key-only / missing file) — last switch target only.
     if (data.activeId && data.accounts.some((a) => a.id === data.activeId)) {
       return data.activeId;
     }
+    return undefined;
+  }
+
+  /**
+   * Last switch/save target stored by the app, even when the host Grok login
+   * no longer matches that snapshot (used only for mismatch UI copy).
+   */
+  markedActiveId(): string | undefined {
+    const id = this.store.get().activeId;
+    if (!id) return undefined;
+    return this.store.get().accounts.some((a) => a.id === id) ? id : undefined;
+  }
+
+  /** Whether the host's live login matches the saved account marked active. */
+  liveMatchesActive(): boolean {
     const lid = loginId();
-    if (!lid) return undefined;
-    return data.accounts.find((a) => a.loginId === lid)?.id;
+    if (!lid) return false;
+    const marked = this.markedActiveId();
+    if (!marked) return this.activeAccountId() !== undefined;
+    const meta = this.get(marked);
+    return !!meta?.loginId && meta.loginId === lid;
   }
 
   get(id: string): StoredAccount | undefined {
@@ -117,19 +144,32 @@ export class AccountManager {
     }
     const label = customLabel?.trim() || loginLabel() || `account ${lid.slice(0, 6)}`;
     const email = loginLabel();
-    // Match by token hash first; fall back to the currently marked active slot
-    // when the user is re-saving after a silent token refresh.
-    const existing =
-      this.store.get().accounts.find((a) => a.loginId === lid) ??
-      (this.store.get().activeId ? this.get(this.store.get().activeId!) : undefined);
+    // Match by token hash first. Only reuse the marked active slot when it is
+    // the same login (token refresh) or the same email — never overwrite a
+    // different saved account when the host is signed in as someone else.
+    const accounts = this.store.get().accounts;
+    const byToken = accounts.find((a) => a.loginId === lid);
+    const active = this.store.get().activeId ? this.get(this.store.get().activeId!) : undefined;
+    const emailKey = email?.toLowerCase();
+    const byEmail =
+      emailKey && emailKey.includes("@")
+        ? accounts.find((a) => (a.email || a.label || "").toLowerCase() === emailKey)
+        : undefined;
+    const sameActiveRefresh =
+      active &&
+      (active.loginId === lid ||
+        (!!emailKey &&
+          emailKey.includes("@") &&
+          [active.email, active.label].some((v) => (v || "").toLowerCase() === emailKey)));
+    const existing = byToken ?? (sameActiveRefresh ? active : undefined) ?? byEmail;
     const id = existing?.id ?? makeId();
     await writeFile(this.snapshotPath(id), raw, "utf-8");
     const meta: StoredAccount = {
       id,
       label: customLabel?.trim() || existing?.label || label,
       loginId: lid,
-      email: email || existing?.email,
-      startUrl: email || existing?.email,
+      email: (email && email.includes("@") ? email : undefined) || existing?.email,
+      startUrl: (email && email.includes("@") ? email : undefined) || existing?.email || existing?.startUrl,
       savedAt: new Date().toISOString(),
     };
     this.store.update((d) => {

package/src/app/grok-credentials.ts

@@ -2,7 +2,7 @@
  * Grok Build login state. The official CLI signs in with your xAI account
  * (`grok login`, browser OIDC) and stores the token in `~/.grok/auth.json`:
  *
- *   { "<scope_url>": { "key": "<token>" }, ... }
+ *   { "<scope_url>": { "key": "<token>", "email"?: "...", ... }, ... }
  *
  * (An `XAI_API_KEY` env var is an alternative for non-browser hosts.) This
  * module reads that file so the bot can show who's signed in, detect a usable
@@ -36,7 +36,19 @@ export function authFileExists(): boolean {
   return existsSync(grokAuthPath());
 }
 
-type AuthFile = Record<string, { key?: string } | undefined>;
+/** One scope entry inside ~/.grok/auth.json (fields beyond `key` are optional). */
+export interface AuthEntry {
+  key?: string;
+  email?: string;
+  first_name?: string;
+  last_name?: string;
+  user_id?: string;
+  principal_id?: string;
+  auth_mode?: string;
+  [extra: string]: unknown;
+}
+
+export type AuthFile = Record<string, AuthEntry | undefined>;
 
 export function readAuth(): AuthFile {
   try {
@@ -46,12 +58,18 @@ export function readAuth(): AuthFile {
   }
 }
 
+/** Active scope entry (OIDC preferred, then legacy). */
+export function currentAuthEntry(auth: AuthFile = readAuth()): AuthEntry | undefined {
+  const oidc = auth[OIDC_SCOPE];
+  if (oidc?.key?.trim()) return oidc;
+  const legacy = auth[LEGACY_SCOPE];
+  if (legacy?.key?.trim()) return legacy;
+  return undefined;
+}
+
 /** The active sign-in token from auth.json (OIDC preferred, then legacy). */
 export function currentToken(auth: AuthFile = readAuth()): string | undefined {
-  const oidc = auth[OIDC_SCOPE]?.key?.trim();
-  if (oidc) return oidc;
-  const legacy = auth[LEGACY_SCOPE]?.key?.trim();
-  return legacy || undefined;
+  return currentAuthEntry(auth)?.key?.trim() || undefined;
 }
 
 /** Whether a usable login exists (a token in auth.json, or XAI_API_KEY). */
@@ -81,16 +99,33 @@ function decodeJwtPayload(jwt: string): Record<string, unknown> | undefined {
   }
 }
 
-/** Best-effort identity (email/name) decoded from the sign-in JWT. */
+/**
+ * Best-effort identity (email/name). Prefer fields Grok writes on the auth
+ * entry (`email`, `first_name`, …) — modern access tokens often omit email
+ * claims — then fall back to JWT claims when present.
+ */
 export function identityFromAuth(auth: AuthFile = readAuth()): LoginIdentity {
-  const tok = currentToken(auth);
-  if (!tok) return {};
-  const claims = decodeJwtPayload(tok);
-  if (!claims) return {};
-  const str = (k: string): string | undefined => (typeof claims[k] === "string" ? (claims[k] as string) : undefined);
-  const emailish = str("email") || str("preferred_username") || str("upn");
-  const email = emailish && emailish.includes("@") ? emailish : undefined;
-  return { email, name: str("name") || str("given_name") };
+  const entry = currentAuthEntry(auth);
+  if (!entry) return {};
+
+  const entryEmail = typeof entry.email === "string" && entry.email.includes("@") ? entry.email : undefined;
+  const entryName = [entry.first_name, entry.last_name]
+    .filter((p): p is string => typeof p === "string" && p.trim().length > 0)
+    .join(" ")
+    .trim() || undefined;
+
+  const tok = entry.key?.trim();
+  const claims = tok ? decodeJwtPayload(tok) : undefined;
+  const str = (k: string): string | undefined =>
+    claims && typeof claims[k] === "string" ? (claims[k] as string) : undefined;
+  const claimEmailish = str("email") || str("preferred_username") || str("upn");
+  const claimEmail = claimEmailish && claimEmailish.includes("@") ? claimEmailish : undefined;
+  const claimName = str("name") || str("given_name");
+
+  return {
+    email: entryEmail || claimEmail,
+    name: entryName || claimName,
+  };
 }
 
 /** A short human label for the active login (email, else a short token hash). */

package/src/bot/bot.ts

@@ -125,8 +125,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
 
   // Permission handling: default is auto-approve (prefer "this session" / always).
   // Interactive Approve/Deny buttons only when both trust-all and auto-approve are off.
+  // Interactive prompts are pinned so they aren't lost in a busy chat; on
+  // settle we re-pin the status panel (private chats keep a single pin).
   const autoApprovePerms = cfg.autoApprovePermissions || cfg.trustAllTools;
-  const permissions = new PermissionService(bot.api, registry, autoApprovePerms);
+  const permissions = new PermissionService(bot.api, registry, autoApprovePerms, {
+    onUnpinned: (chatId) => statusPanel.ensurePinned(chatId),
+  });
   acp.permissionHandler = (p) => permissions.handle(p);
 
   // The bot pins/unpins the status panel, and Telegram emits a "pinned a
@@ -147,9 +151,14 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   });
 
   bot.callbackQuery(/^perm:(\d+):(\d+)$/, async (ctx) => {
+    // resolveChoice unpins the prompt; we then rewrite it to the chosen label.
     const label = permissions.resolveChoice(ctx.match![1]!, Number(ctx.match![2]));
     await ctx.answerCallbackQuery({ text: label ?? "Expired" });
-    await ctx.editMessageText(label ? `\u{1F510} ${label}` : "\u{1F510} (expired)").catch(() => {});
+    await ctx
+      .editMessageText(label ? `\u{1F510} ${label}` : "\u{1F510} (expired)", {
+        reply_markup: { inline_keyboard: [] },
+      })
+      .catch(() => {});
   });
 
   bot.callbackQuery(/^permsw:(\d+)$/, async (ctx) => {

package/src/bot/handlers/accounts.ts

@@ -25,14 +25,28 @@ async function view(deps: BotDeps, note?: string): Promise<{ text: string; keybo
   const list = deps.accounts.list();
   const acct = await deps.usage.account().catch(() => undefined);
   const active = deps.accounts.activeAccountId();
+  const marked = deps.accounts.markedActiveId();
   const loggedIn = await deps.usage.isLoggedIn().catch(() => false);
+  const liveLabel = acct?.email?.trim();
+  const activeMeta = active ? deps.accounts.get(active) : undefined;
+  const markedMeta = marked && marked !== active ? deps.accounts.get(marked) : undefined;
 
   const lines = ["\u{1F465} Grok accounts", ""];
-  if (loggedIn && acct?.email && !active) {
-    lines.push(`\u{1F7E2} Signed in as ${acct.email}`);
-    lines.push("  \u2514 Not saved yet — tap \u201C\u{1F4BE} Save current login\u201D to keep it.", "");
-  } else if (!loggedIn) {
+  if (!loggedIn) {
     lines.push("\u{1F534} Not signed in — sign in via /reauth.", "");
+  } else if (liveLabel) {
+    lines.push(`\u{1F7E2} Host Grok login: ${liveLabel}`);
+    if (activeMeta) {
+      lines.push(`  \u2514 Matches saved: ${activeMeta.label}`);
+    } else {
+      lines.push("  \u2514 Not among saved accounts — tap \u201C\u{1F4BE} Save current login\u201D.");
+      if (markedMeta) {
+        lines.push(`  \u2514 App still has ${markedMeta.label} selected — different from host login.`);
+      }
+    }
+    lines.push("");
+  } else {
+    lines.push("\u{1F7E2} Signed in (identity unknown).", "");
   }
   if (list.length === 0) {
     lines.push("No saved accounts yet.", "", "Save the current login below, or sign in via /reauth.");

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

@@ -153,6 +153,20 @@ export class StatusPanel {
       log.debug("status create/pin failed:", (err as Error).message);
     }
   }
+
+  /**
+   * Re-pin the existing status panel (if any). Used after a temporary pin
+   * (e.g. a permission prompt) is unpinned so the status panel stays visible.
+   */
+  async ensurePinned(chatId: number): Promise<void> {
+    const id = this.settings.get(chatId).statusMessageId;
+    if (!id) return;
+    try {
+      await this.api.pinChatMessage(chatId, id, { disable_notification: true });
+    } catch (err) {
+      log.debug("status re-pin failed:", (err as Error).message);
+    }
+  }
 }
 
 function isNotModified(err: unknown): boolean {

package/src/bot/permission-service.ts

@@ -2,6 +2,9 @@
  * PermissionService — turns Grok's ACP `session/request_permission` into either
  * an automatic session-level approval (default) or inline Approve/Deny buttons.
  *
+ * Interactive prompts are **pinned** so they stay visible while the chat is
+ * busy streaming other messages, then **unpinned** on approve / deny / timeout.
+ *
  * Auto-approve prefers "allow for this session" / "always allow" options so the
  * agent stops re-prompting mid-turn. Interactive mode is only used when
  * auto-approve is off (GROK_TRUST_ALL_TOOLS=false and AUTO_APPROVE_PERMISSIONS=false).
@@ -31,6 +34,16 @@ interface Pending {
   sessionId: string;
   messageId?: number;
   timer: NodeJS.Timeout;
+  /** True once the message has been pinned (so we know to unpin on settle). */
+  pinned: boolean;
+}
+
+export interface PermissionServiceOptions {
+  /**
+   * Called after a permission prompt is unpinned (approve / deny / timeout).
+   * Use to re-pin the status panel if Telegram only keeps one pin per chat.
+   */
+  onUnpinned?: (chatId: number) => void | Promise<void>;
 }
 
 export class PermissionService {
@@ -38,13 +51,16 @@ export class PermissionService {
   private seq = 0;
   /** When true, every permission request is auto-approved (session-scope preferred). */
   autoApprove: boolean;
+  private readonly onUnpinned?: (chatId: number) => void | Promise<void>;
 
   constructor(
     private readonly api: Api,
     private readonly registry: RuntimeRegistry,
     autoApprove = true,
+    opts?: PermissionServiceOptions,
   ) {
     this.autoApprove = autoApprove;
+    this.onUnpinned = opts?.onUnpinned;
   }
 
   /** Handle a permission request: auto-approve (default), ask the chat, or allow if unattended. */
@@ -78,6 +94,7 @@ export class PermissionService {
     if (canSwitch) kb.text(`\u{1F500} Switch to ${label}`, `permsw:${reqId}`);
 
     let messageId: number | undefined;
+    let pinned = false;
     try {
       const msg = await this.api.sendMessage(
         chatId,
@@ -88,6 +105,14 @@ export class PermissionService {
         },
       );
       messageId = msg.message_id;
+      // Pin so the prompt stays visible while the chat streams other messages.
+      // disable_notification:true — the send already notified; no second ping.
+      try {
+        await this.api.pinChatMessage(chatId, messageId, { disable_notification: true });
+        pinned = true;
+      } catch (e) {
+        log.warn("failed to pin permission prompt:", (e as Error).message);
+      }
     } catch (e) {
       log.warn("failed to send permission prompt:", (e as Error).message);
       return autoDecideSession(params);
@@ -95,11 +120,21 @@ export class PermissionService {
 
     return new Promise<PermissionOutcome>((resolve) => {
       const timer = setTimeout(() => {
+        const p = this.pending.get(reqId);
+        if (!p) return;
         this.pending.delete(reqId);
-        void this.api.editMessageText(chatId, messageId!, "\u231B Approval timed out \u2014 denied.").catch(() => {});
+        void this.finishPrompt(p, "\u231B Approval timed out \u2014 denied.");
         resolve({ outcome: { outcome: "cancelled" } });
       }, TIMEOUT_MS);
-      this.pending.set(reqId, { resolve, options: params.options, chatId, sessionId: params.sessionId, messageId, timer });
+      this.pending.set(reqId, {
+        resolve,
+        options: params.options,
+        chatId,
+        sessionId: params.sessionId,
+        messageId,
+        timer,
+        pinned,
+      });
     });
   }
 
@@ -111,9 +146,12 @@ export class PermissionService {
     this.pending.delete(reqId);
     const opt = p.options[index];
     if (!opt) {
+      void this.finishPrompt(p, "\u{1F510} (cancelled)");
       p.resolve({ outcome: { outcome: "cancelled" } });
       return undefined;
     }
+    // Unpin + mark resolved (caller typically edits the message text too).
+    void this.unpinOnly(p);
     p.resolve({ outcome: { outcome: "selected", optionId: opt.optionId } });
     return opt.name;
   }
@@ -122,6 +160,31 @@ export class PermissionService {
   sessionFor(reqId: string): string | undefined {
     return this.pending.get(reqId)?.sessionId;
   }
+
+  /** Unpin (if pinned) and optionally rewrite the prompt message. */
+  private async finishPrompt(p: Pending, text?: string): Promise<void> {
+    if (p.messageId !== undefined && text) {
+      await this.api.editMessageText(p.chatId, p.messageId, text, { reply_markup: { inline_keyboard: [] } }).catch(() => {});
+    }
+    await this.unpinOnly(p);
+  }
+
+  /** Unpin the permission prompt and restore the status pin if any. */
+  private async unpinOnly(p: Pending): Promise<void> {
+    if (p.pinned && p.messageId !== undefined) {
+      p.pinned = false;
+      await this.api.unpinChatMessage(p.chatId, p.messageId).catch((e) => {
+        log.debug("unpin permission prompt failed:", (e as Error).message);
+      });
+    }
+    if (this.onUnpinned) {
+      try {
+        await this.onUnpinned(p.chatId);
+      } catch (e) {
+        log.debug("onUnpinned hook failed:", (e as Error).message);
+      }
+    }
+  }
 }
 
 function describe(

package/scripts/_push-branch.mjs

@@ -1,89 +0,0 @@
-import { readFileSync } from "node:fs";
-import { spawnSync } from "node:child_process";
-
-const files = [
-  ".env.example",
-  "CHANGELOG.md",
-  "src/app/accounts.ts",
-  "src/app/auth-service.ts",
-  "src/bot/account-rotator.ts",
-  "src/bot/bot.ts",
-  "src/bot/handlers/accounts.ts",
-  "src/bot/permission-service.ts",
-  "src/bot/reauth-controller.ts",
-  "src/config.ts",
-  "src/grok/client.ts",
-  "test/auth-and-permissions.test.ts",
-];
-
-const owner = "artickc";
-const repo = "grok-telegram-bot";
-const branch = "feat/fix-rotation-and-auto-approve";
-const message =
-  "fix: account rotation swaps auth.json headlessly; auto-approve session permissions";
-
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
-
-function ghApi(method, path, body) {
-  const args = ["api", "-X", method, path];
-  const opts = {
-    encoding: "utf8",
-    maxBuffer: 50 * 1024 * 1024,
-    shell: false,
-    env: { ...process.env, NO_COLOR: "1", CLICOLOR: "0", FORCE_COLOR: "0", GH_FORCE_TTY: "0" },
-  };
-  if (body !== undefined) {
-    args.push("--input", "-");
-    opts.input = JSON.stringify(body);
-  }
-  const r = spawnSync("gh", args, opts);
-  if (r.status !== 0) {
-    throw new Error(`gh api ${method} ${path} failed (${r.status}): ${r.stderr || r.stdout}`);
-  }
-  const text = (r.stdout || "").replace(ANSI_RE, "").trim();
-  if (!text) return {};
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    throw new Error(`JSON parse failed for ${method} ${path}: ${text.slice(0, 200)}`);
-  }
-}
-
-const refPath = `repos/${owner}/${repo}/git/ref/heads/${branch}`;
-const ref = ghApi("GET", refPath);
-const baseSha = ref.object.sha;
-console.log("base", baseSha);
-
-const baseCommit = ghApi("GET", `repos/${owner}/${repo}/git/commits/${baseSha}`);
-const baseTree = baseCommit.tree.sha;
-
-const tree = [];
-for (const path of files) {
-  const content = readFileSync(path, "utf8");
-  const blob = ghApi("POST", `repos/${owner}/${repo}/git/blobs`, {
-    content: Buffer.from(content, "utf8").toString("base64"),
-    encoding: "base64",
-  });
-  tree.push({ path, mode: "100644", type: "blob", sha: blob.sha });
-  console.log("blob", path, blob.sha.slice(0, 8));
-}
-
-const newTree = ghApi("POST", `repos/${owner}/${repo}/git/trees`, {
-  base_tree: baseTree,
-  tree,
-});
-console.log("tree", newTree.sha);
-
-const commit = ghApi("POST", `repos/${owner}/${repo}/git/commits`, {
-  message,
-  tree: newTree.sha,
-  parents: [baseSha],
-});
-console.log("commit", commit.sha);
-
-ghApi("PATCH", `repos/${owner}/${repo}/git/refs/heads/${branch}`, {
-  sha: commit.sha,
-  force: false,
-});
-console.log("updated", branch, "->", commit.sha);