grok-telegram-bot 2.2.4 → 2.3.1

package/.env.example

@@ -132,9 +132,12 @@ QUIET_NOTIFICATIONS=true
 # LOG_DIR=
 # LOG_FILE=
 
-# ── Voice messages (speech-to-text) ──────────────────────────────────────────
-# Any OpenAI/Whisper-compatible transcription endpoint. xAI offers one too:
-# STT_API_URL=https://api.x.ai/v1
+# ── Voice messages (optional) ────────────────────────────────────────────────
+# Voice is ONLY available when STT is configured. Grok Build CLI over ACP does
+# not accept audio content blocks, so without STT the bot replies that voice
+# isn't configured. Use any OpenAI/Whisper-compatible transcription endpoint
+# (including xAI STT if your gateway exposes /audio/transcriptions):
+# STT_API_URL=https://api.openai.com/v1
 # STT_API_KEY=
 # STT_MODEL=whisper-1
-# STT_LANGUAGE=
+# STT_LANGUAGE=                # blank = auto-detect

package/CHANGELOG.md

@@ -7,29 +7,74 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 The latest section is published verbatim as the GitHub Release notes by
 `.github/workflows/release.yml` when a `vX.Y.Z` tag is pushed.
 
-## [Unreleased]
-
-## [2.2.4] - 2026-07-16
-
-### Fixed
-
-- **🚫 Rotate immediately on Grok access denial.** API `403 Forbidden` / `Access
-  denied` responses now bypass same-account retry backoff, mark the failed
-  login with `⚠️`, and rotate to the next eligible saved account. If the active
-  host login was not already saved (for example after an external sign-in or
-  token refresh), it is captured first so the warning is visible and persists.
-- **🔐 Isolated Grok Telegram identity.** The Grok bot now takes its Telegram
-  token from its own instance `.env` before considering an inherited process
-  environment value. This prevents a machine-wide token for a sibling bot from
-  making Grok poll as Codex/Kiro/OpenCode and causing Telegram conflicts.
-- **⚠️ Persistent account warnings.** Account access/quota failures are shown
-  in `/accounts`, excluded from later automatic rotations, and can be manually
-  re-enabled after the account is repaired.
-- **🛟 No false success for silent ACP turns.** A Grok ACP completion with no
-  text, thought, or tool update is now treated as a recoverable agent failure
-  instead of reporting `Done · no text output`.
-
-## [2.2.3] - 2026-07-13
+## [Unreleased]
+
+## [2.3.1] - 2026-07-19
+
+### Fixed
+
+- **Stable account rotation across concurrent chats.** Account selection is now
+  serialized around the single shared Grok CLI process. Chats reuse the working
+  account selected by another session and create their own ACP session instead
+  of starting competing rotation loops that repeatedly restart the agent.
+- **Session failures no longer condemn valid accounts.** `unknown session id`,
+  agent-restart/process-exit, and headless-auth initialization errors now trigger
+  a session rebind/retry on the active account rather than quarantining or
+  cycling functional logins.
+- **Reliable restart propagation.** Credential imports, manual switches,
+  reauthentication, and automatic rotation notify every chat runtime after the
+  shared process restarts; new session binding waits until candidate validation
+  completes.
+
+## [2.3.0] - 2026-07-17
+
+### Added
+
+- **⚡ Instant project switch.** Choosing a project no longer waits on ACP
+  `session/new`. The bot switches cwd immediately and creates the live session
+  lazily on the first message. Reuses an existing controlled runtime for the
+  same path when available.
+- **🖼 Image-output prompt rules.** When agent image return is enabled, prompts
+  include rules to keep generated files in the Grok session media folder
+  (`images/` / `assets/`) or project `images/`, and to report absolute paths.
+
+### Fixed
+
+- **🖼 Agent images as Telegram files.** Generated images are sent with
+  `sendDocument` (downloadable file) instead of compressed `sendPhoto`. Discovery
+  now scans Grok session `images/` **and** `assets/`, plus project `images/` and
+  tool/text paths (Imagine was writing under `images/` while the bot only scanned
+  `assets/`).
+- **⏱ Stale callback queries.** Callback answers are safe/idempotent; expired
+  Telegram query IDs no longer spam ERROR logs. Handlers answer before slow ACP
+  work (stop / model / agent / project open).
+- **🎙 Voice requires STT again.** Voice / audio / video notes only work when
+  `STT_API_URL` is set (optional `STT_API_KEY`). Without STT the bot replies that
+  voice isn't configured — the CLI cannot accept ACP audio blocks.
+- **🔄 Non-blocking session handoff.** Backgrounding a session no longer waits
+  on streamer finalize / `prepare()` mid-switch, so the bot stays responsive.
+
+## [2.2.4] - 2026-07-16
+
+### Fixed
+
+- **🚫 Rotate immediately on Grok access denial.** API `403 Forbidden` / `Access
+  denied` responses now bypass same-account retry backoff, mark the failed
+  login with `⚠️`, and rotate to the next eligible saved account. If the active
+  host login was not already saved (for example after an external sign-in or
+  token refresh), it is captured first so the warning is visible and persists.
+- **🔐 Isolated Grok Telegram identity.** The Grok bot now takes its Telegram
+  token from its own instance `.env` before considering an inherited process
+  environment value. This prevents a machine-wide token for a sibling bot from
+  making Grok poll as Codex/Kiro/OpenCode and causing Telegram conflicts.
+- **⚠️ Persistent account warnings.** Account access/quota failures are shown
+  in `/accounts`, excluded from later automatic rotations, and can be manually
+  re-enabled after the account is repaired.
+- **🛟 No false success for silent ACP turns.** A Grok ACP completion with no
+  text, thought, or tool update is now treated as a recoverable agent failure
+  instead of reporting `Done · no text output`.
+
+## [2.2.3] - 2026-07-13
 
 ### Fixed
 
@@ -733,6 +778,10 @@ 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.3.1]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.1
+[2.3.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.0
+[2.2.4]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.4
+[2.2.3]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.3
 [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

package/README.md

@@ -275,16 +275,25 @@ caption. The bot downloads them and attaches them all to the prompt as image
 content blocks, so the agent can analyze them together. Images sent while Grok
 is busy are queued with your next turn.
 
-**Images come back too:** when the agent produces images during a turn (e.g.
-takes screenshots while testing an app), the bot detects the freshly-written
-files and sends them back to Telegram automatically (`SEND_AGENT_IMAGES`).
+**Images come back too:** when the agent produces images during a turn — Imagine
+`image_gen` / `image_edit` (written under
+`~/.grok/sessions/<cwd>/<session>/images/` and `…/assets/`), screenshots, or
+files under `<project>/images/` — the bot detects the freshly-written files and
+sends them back to Telegram as **downloadable documents** (`SEND_AGENT_IMAGES`,
+default on). Prompts also include image-output rules so the agent keeps gens in
+the session media folder and reports absolute paths.
 
 ## 🎙 Sending voice
 
-Send a voice note (or audio file) and the bot transcribes it and runs it as a
-prompt. Configure any OpenAI/Whisper-compatible endpoint via `STT_API_URL` in
-`.env`; leave `STT_LANGUAGE` blank for automatic detection (English, Russian,
-Romanian/Moldovan, and ~100 more).
+Send a voice note, audio file, or video note and the bot runs it as a prompt
+**only when STT is configured**.
+
+Set any OpenAI/Whisper-compatible endpoint via `STT_API_URL` (and `STT_API_KEY`
+if needed). The bot transcribes, shows the quote, and submits plain text.
+Without `STT_API_URL`, voice is rejected with a short “not configured” message
+— Grok Build CLI rejects ACP `audio` content blocks, so raw audio cannot be
+heard by the agent. Leave `STT_LANGUAGE` blank for automatic detection
+(English, Russian, Romanian/Moldovan, and ~100 more).
 
 ## 📎 Sending files
 
@@ -530,7 +539,8 @@ user. See [SECURITY.md](./SECURITY.md) for the full model.
 - [x] Multi-image prompts (albums)
 - [x] Combined, throttled output (anti-spam)
 - [x] 24/7 cross-platform background service
-- [x] Voice messages → speech-to-text → prompt (multi-language)
+- [x] Voice messages → STT (`STT_API_URL`) → text prompt (disabled without STT)
+- [x] Agent-generated images → Telegram document files (session `images/`/`assets/`)
 - [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.2.4",
+  "version": "2.3.1",
   "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/src/app/stt.ts

@@ -1,9 +1,12 @@
 /**
  * Speech-to-text via any OpenAI/Whisper-compatible endpoint.
  *
+ * Required for Telegram voice / audio / video notes: Grok Build CLI over ACP
+ * does not accept audio content blocks, so without STT_API_URL the bot rejects
+ * voice with a "not configured" message instead of attaching unusable audio.
+ *
  * Language handling: when STT_LANGUAGE is unset, Whisper auto-detects the
- * spoken language (covers English, Russian, Romanian/Moldovan, and ~100 more),
- * so multilingual voice notes work out of the box.
+ * spoken language (covers English, Russian, Romanian/Moldovan, and ~100 more).
  */
 import { createLogger } from "../logger.js";
 

package/src/app/types.ts

@@ -37,10 +37,24 @@ export interface PromptImage {
   mimeType: string;
 }
 
-/** A unit of work submitted to the agent: text plus optional images. */
+/**
+ * A file the agent can open (ACP `resource_link`). Used for voice notes and
+ * other binaries when we cannot embed the media as a first-class content type
+ * (Grok CLI currently rejects ACP `audio` blocks).
+ */
+export interface PromptResourceLink {
+  uri: string;
+  name: string;
+  mimeType?: string;
+  size?: number;
+}
+
+/** A unit of work submitted to the agent: text plus optional images / links. */
 export interface PromptInput {
   text: string;
   images: PromptImage[];
+  /** Optional file references (voice notes, binaries). */
+  resourceLinks?: PromptResourceLink[];
   /** Telegram message id of the prompt, so the reply threads to it. */
   replyTo?: number;
   /**
@@ -52,5 +66,5 @@ export interface PromptInput {
 }
 
 export function textPrompt(text: string, replyTo?: number, quotedText?: string): PromptInput {
-  return { text, images: [], replyTo, quotedText };
+  return { text, images: [], resourceLinks: [], replyTo, quotedText };
 }

package/src/bot/account-rotator.ts

@@ -30,6 +30,12 @@ export interface RotationTarget {
   label: string;
 }
 
+export interface RotationState {
+  generation: number;
+  activeId?: string;
+  activeLabel?: string;
+}
+
 export interface AccountRotator {
   /** Whether auto-rotate is switched on. */
   enabled(): boolean;
@@ -39,9 +45,19 @@ export interface AccountRotator {
   activate(id: string): Promise<void>;
   /** Quarantine an account after an account-specific failure. Undefined means active. */
   markFailed(id: string | undefined, reason: string): Promise<void>;
+  /** Process/account generation observed when a turn failed. */
+  state(): RotationState;
+  /** Serialize a complete rotation probe. `changed` means another chat already
+   * selected/restarted an account while this caller was waiting. */
+  withRotationLock<T>(observed: RotationState, run: (changed: boolean) => Promise<T>): Promise<T>;
+  /** Wait for an in-progress rotation probe before re-binding a stale session. */
+  waitForIdle(): Promise<void>;
 }
 
 export class AccountRotatorImpl implements AccountRotator {
+  private generation = 0;
+  private rotationTail: Promise<void> = Promise.resolve();
+
   constructor(
     private readonly accounts: AccountManager,
     private readonly acp: GrokClient,
@@ -51,6 +67,42 @@ export class AccountRotatorImpl implements AccountRotator {
     return this.accounts.autoRotateEnabled();
   }
 
+  state(): RotationState {
+    const activeId = this.accounts.activeAccountId();
+    return {
+      generation: this.generation,
+      activeId,
+      activeLabel: activeId ? this.accounts.get(activeId)?.label : undefined,
+    };
+  }
+
+  async withRotationLock<T>(observed: RotationState, run: (changed: boolean) => Promise<T>): Promise<T> {
+    const previous = this.rotationTail;
+    let release!: () => void;
+    this.rotationTail = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      const current = this.state();
+      const changed =
+        current.generation !== observed.generation || current.activeId !== observed.activeId;
+      return await run(changed);
+    } finally {
+      release();
+    }
+  }
+
+  async waitForIdle(): Promise<void> {
+    // Include work queued while we were waiting, not only the first captured
+    // promise, so callers never re-bind in the middle of a candidate switch.
+    for (;;) {
+      const pending = this.rotationTail;
+      await pending;
+      if (pending === this.rotationTail) return;
+    }
+  }
+
   async targets(): Promise<RotationTarget[]> {
     const list = this.accounts.list();
     const activeId = this.accounts.activeAccountId();
@@ -96,12 +148,19 @@ export class AccountRotatorImpl implements AccountRotator {
       log.info(`rotating: auth.json now ${meta.label}; starting Grok CLI + re-auth`);
       // start() → connect() → initialize + authenticate(cached_token) against
       // the freshly written auth.json. A live process would keep the old token.
-      await this.acp.start();
+      await this.acp.start(true);
+      this.generation++;
       log.info(`rotating: Grok CLI up on ${meta.label}`);
     } catch (e) {
       // Best-effort recover the agent so the bot stays usable even if the
       // target login was bad.
-      await this.acp.start().catch((err) => log.warn("post-rotate restart failed:", (err as Error).message));
+      await this.acp.stopAndWait().catch(() => {});
+      await this.acp
+        .start(true)
+        .then(() => {
+          this.generation++;
+        })
+        .catch((err) => log.warn("post-rotate restart failed:", (err as Error).message));
       throw e;
     }
   }

package/src/bot/bot.ts

@@ -20,6 +20,7 @@ import { TaskRunner } from "../tasks/runner.js";
 import { Scheduler } from "../tasks/scheduler.js";
 import { TaskStore } from "../tasks/store.js";
 import { createAuthMiddleware } from "./auth.js";
+import { isStaleCallbackError, safeCallbackMiddleware } from "./callback.js";
 import { COMMANDS } from "./commands.js";
 import { type BotDeps, MenuCache } from "./deps.js";
 import { registerControl } from "./handlers/control.js";
@@ -139,6 +140,9 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   bot.on("message:pinned_message", (ctx) => void ctx.deleteMessage().catch(() => {}));
 
   bot.use(createAuthMiddleware(cfg));
+  // Answer callback queries safely: never throw on stale IDs, auto-answer if a
+  // handler forgets (prevents the loading spinner + unhandled 400 noise).
+  bot.use(safeCallbackMiddleware());
 
   // Keep history clean: after handling, delete the user's command (/…) and
   // persistent-bar button taps. Plain prompts and wizard input are kept.
@@ -188,6 +192,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   registerMessages(bot, deps); // catch-all text prompt — keep last
 
   bot.catch((err) => {
+    // Stale callback answers are expected when the bot was busy past Telegram's
+    // ~timeout — middleware already swallows most of them; keep noise out of ERROR.
+    if (isStaleCallbackError(err.error)) {
+      log.debug("stale callback query:", err.error instanceof Error ? err.error.message : err.error);
+      return;
+    }
     log.error("unhandled bot error:", err.error instanceof Error ? err.error.message : err.error);
   });
 

package/src/bot/callback.ts

@@ -0,0 +1,74 @@
+/**
+ * Callback-query helpers — Telegram requires answerCallbackQuery within a few
+ * seconds of the tap. Stale/expired IDs throw 400; without a catch those become
+ * unhandled bot errors and the client spinner never clears.
+ */
+import { type Context, type MiddlewareFn, GrammyError } from "grammy";
+
+/** True when Telegram rejected the answer because the query expired or is invalid. */
+export function isStaleCallbackError(err: unknown): boolean {
+  if (!(err instanceof GrammyError)) return false;
+  if (err.error_code !== 400 && err.error_code !== 440) return false;
+  return /query is too old|query ID is invalid|response timeout expired/i.test(err.description);
+}
+
+type AnswerParams = Parameters<Context["answerCallbackQuery"]>[0];
+
+/**
+ * Idempotent, non-throwing answer for a single handler (when middleware is not
+ * in play). Safe to call after slow work — stale queries are swallowed.
+ */
+export async function safeAnswerCallbackQuery(ctx: Context, params?: AnswerParams): Promise<boolean> {
+  try {
+    await ctx.answerCallbackQuery(params);
+    return true;
+  } catch (err) {
+    if (isStaleCallbackError(err)) return false;
+    throw err;
+  }
+}
+
+/**
+ * Patch every callback update so:
+ *   1. answerCallbackQuery never throws on stale/expired query IDs,
+ *   2. double-answers are no-ops,
+ *   3. if a handler forgets to answer, we answer once in `finally` so the
+ *      client spinner always stops (best-effort; may already be too late).
+ */
+export function safeCallbackMiddleware(): MiddlewareFn<Context> {
+  return async (ctx, next) => {
+    if (!ctx.callbackQuery) {
+      await next();
+      return;
+    }
+
+    let answered = false;
+    const original = ctx.answerCallbackQuery.bind(ctx);
+
+    ctx.answerCallbackQuery = (async (params?: AnswerParams) => {
+      if (answered) return true;
+      answered = true;
+      try {
+        return await original(params);
+      } catch (err) {
+        if (isStaleCallbackError(err)) return true;
+        // Leave answered=true so a retry storm can't spam Telegram; surface
+        // unexpected errors to bot.catch for visibility.
+        throw err;
+      }
+    }) as Context["answerCallbackQuery"];
+
+    try {
+      await next();
+    } finally {
+      if (!answered) {
+        try {
+          await original();
+        } catch {
+          /* stale or network — spinner already gone */
+        }
+        answered = true;
+      }
+    }
+  };
+}

package/src/bot/chat-controller.ts

@@ -79,20 +79,69 @@ export class ChatController {
     }));
   }
 
-  /** Start a brand-new session and bring it to the foreground. */
+  /** Start a brand-new session and bring it to the foreground.
+   *  Always binds a live ACP session (`session/new`) — use {@link switchProject}
+   *  when you only need to change the working directory (instant). */
   async addNew(cwd: string, projectName?: string): Promise<SessionRuntime> {
     this.ensureRestored();
     const prevFg = this.fg;
     const rt = this.create({ cwd, projectName });
     this.runtimes.push(rt);
     this.fg = rt;
-    await this.background(prevFg);
+    // Fire-and-forget: finalizing the previous streamer must not block the new
+    // session bind (that was a major source of "bot freezes on switch").
+    void this.background(prevFg);
     await rt.startNewSession(cwd, projectName);
     this.markSeen(rt);
     this.persist();
     return rt;
   }
 
+  /**
+   * Switch the chat to a project directory **without** waiting on ACP.
+   * - Reuses an existing controlled runtime for the same path when possible.
+   * - Does **not** call `session/new` — the live session is created lazily on
+   *   the first prompt / prepare (via `ensureSession`).
+   * This keeps the project picker responsive even while another turn is running.
+   */
+  async switchProject(cwd: string, projectName?: string): Promise<SessionRuntime> {
+    this.ensureRestored();
+    const key = normPath(cwd);
+    const same = this.runtimes.filter((r) => normPath(r.cwd) === key);
+    // Prefer the current FG if it already points here, else the most recent match.
+    const existing = same.find((r) => r === this.fg) ?? same.at(-1);
+
+    if (existing) {
+      if (projectName) existing.projectName = projectName;
+      if (existing === this.fg) {
+        this.persist();
+        return existing;
+      }
+      if (existing.sessionId) {
+        // Fast path: switchTo no longer awaits ACP re-bind.
+        const sw = await this.switchTo(existing.sessionId);
+        return sw?.rt ?? existing;
+      }
+      void this.background(this.fg);
+      this.fg = existing;
+      await existing.setForeground(true);
+      this.persist();
+      return existing;
+    }
+
+    const prevFg = this.fg;
+    const rt = this.create({ cwd, projectName });
+    this.runtimes.push(rt);
+    this.fg = rt;
+    void this.background(prevFg);
+    // Drop other never-used project placeholders (no session yet) so rapid
+    // project browsing can't accumulate infinite idle runtimes/listeners.
+    this.pruneUnusedPlaceholders(rt);
+    // No startNewSession — sessionId stays undefined until the first message.
+    this.persist();
+    return rt;
+  }
+
   /**
    * Connect to a session with resume-or-fork semantics (used by /sessions),
    * adding it as a controlled session and bringing it to the foreground.
@@ -114,7 +163,7 @@ export class ChatController {
     const rt = this.create({ cwd, projectName, sessionId });
     this.runtimes.push(rt);
     this.fg = rt;
-    await this.background(prevFg);
+    void this.background(prevFg);
     const result = await rt.attach(sessionId, cwd, projectName, priorEntries);
     this.markSeen(rt);
     this.persist();
@@ -131,8 +180,8 @@ export class ChatController {
     const rt = this.create({ cwd, projectName, sessionId });
     this.runtimes.push(rt);
     this.fg = rt;
-    await this.background(prevFg);
-    await rt.prepare().catch(() => {});
+    void this.background(prevFg);
+    // Lazy re-bind on first prompt (rebindPending); don't block the resume UI.
     const path = this.store.jsonlPath(sessionId);
     const unread = readHistory(path, 12);
     this.lastRead.set(sessionId, jsonlSize(path));
@@ -148,10 +197,12 @@ export class ChatController {
     if (rt === this.fg) {
       return { rt, sessionId, projectName: rt.projectName, busy: rt.isBusy, unread: [], firstView: false, alreadyForeground: true };
     }
-    await this.background(this.fg);
+    void this.background(this.fg);
     this.fg = rt;
     await rt.setForeground(true);
-    await rt.prepare().catch(() => {});
+    // Do NOT await prepare()/loadSession here — re-bind is lazy on the next
+    // prompt (rebindPending). Awaiting ACP mid-switch freezes the bot when the
+    // agent is busy with another turn.
 
     const path = this.store.jsonlPath(sessionId);
     const seen = this.lastRead.get(sessionId);
@@ -222,8 +273,23 @@ export class ChatController {
       seen.add(cs.sessionId);
       this.runtimes.push(this.create({ cwd: cs.projectPath, projectName: cs.projectName, sessionId: cs.sessionId }));
     }
+    // Lazy project switches persist projectPath without a sessionId. If the
+    // saved project is not among controlled sessions, recreate an unbound FG
+    // so a restart lands on the project the user last chose.
+    if (s.projectPath) {
+      const key = normPath(s.projectPath);
+      const hasProject = this.runtimes.some((r) => normPath(r.cwd) === key);
+      if (!hasProject) {
+        this.runtimes.push(this.create({ cwd: s.projectPath, projectName: s.projectName }));
+      }
+    }
     if (this.runtimes.length > 0) {
-      const fg = this.runtimes.find((r) => r.sessionId === s.foregroundSessionId) ?? this.runtimes[0]!;
+      let fg = this.runtimes.find((r) => r.sessionId && r.sessionId === s.foregroundSessionId);
+      if (!fg && s.projectPath) {
+        const key = normPath(s.projectPath);
+        fg = this.runtimes.find((r) => normPath(r.cwd) === key);
+      }
+      fg = fg ?? this.runtimes[0]!;
       for (const r of this.runtimes) void r.setForeground(r === fg);
       this.fg = fg;
     }
@@ -284,6 +350,17 @@ export class ChatController {
     await rt.setForeground(false);
   }
 
+  /** Remove idle runtimes that never bound an ACP session (lazy project taps). */
+  private pruneUnusedPlaceholders(keep: SessionRuntime): void {
+    for (let i = this.runtimes.length - 1; i >= 0; i--) {
+      const r = this.runtimes[i]!;
+      if (r === keep || r === this.fg) continue;
+      if (r.sessionId || r.isBusy) continue;
+      r.dispose();
+      this.runtimes.splice(i, 1);
+    }
+  }
+
   private markSeen(rt: SessionRuntime): void {
     if (rt.sessionId) this.lastRead.set(rt.sessionId, jsonlSize(this.store.jsonlPath(rt.sessionId)));
   }
@@ -315,3 +392,8 @@ export class ChatController {
     });
   }
 }
+
+/** Path key for project matching (case / separators / trailing slash). */
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}

package/src/bot/handlers/accounts.ts

@@ -205,9 +205,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 +239,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())