grok-telegram-bot 2.3.1 → 2.5.0

package/src/bot/auth.ts

@@ -1,5 +1,12 @@
 /**
  * Authorization middleware: restricts the bot to ALLOWED_USERS when configured.
+ *
+ * Applies to **private chats and groups/forum topics alike**. User IDs are
+ * comma-separated in env (`ALLOWED_USERS=111,222,333`). Empty set = allow all
+ * (unsafe — especially with TOPIC_GROUP_ID).
+ *
+ * Unauthorized users in groups are ignored silently (no ⛔ spam). Private chats
+ * get one clear denial. Callback taps get a toast.
  */
 import type { Context, NextFunction } from "grammy";
 import type { AppConfig } from "../config.js";
@@ -8,31 +15,105 @@ import { createLogger } from "../logger.js";
 const log = createLogger("auth");
 
 export function createAuthMiddleware(cfg: AppConfig) {
-  const allowAll = cfg.allowedUsers.size === 0;
-  if (allowAll) {
+  if (cfg.allowAllUsers) {
     log.warn("ALLOWED_USERS is empty — the bot will respond to ANY Telegram user.");
+    if (cfg.topicGroupId !== undefined) {
+      log.warn(
+        "TOPIC_GROUP_ID is set with empty ALLOWED_USERS — any group member can drive sessions.",
+      );
+    }
+  } else {
+    log.info(`ALLOWED_USERS: ${cfg.allowedUsers.size} id(s) (private + groups)`);
+    if (cfg.allowedUsers.size === 0) {
+      log.warn(
+        "ALLOWED_USERS was set but no valid numeric ids remain — denying everyone (fail closed).",
+      );
+    }
   }
 
   return async (ctx: Context, next: NextFunction): Promise<void> => {
+    // Bot membership changes (promote/demote) must always reach handlers so
+    // forum readiness can re-probe — not gated on ALLOWED_USERS or from.is_bot.
+    if (ctx.myChatMember) {
+      await next();
+      return;
+    }
+
     const from = ctx.from;
-    // Only a genuine USER action is subject to (and worth replying to) the auth
-    // gate. Ignore everything else silently — most importantly the bot's OWN
-    // updates: the status panel being pinned/unpinned emits a service message
-    // whose `from` is THIS bot (is_bot), and replying "⛔ Not authorized" to
-    // that (or to any service/no-`from` update) spammed the chat with false
-    // rejections. Real unauthorized users still get one clear reply below.
+    // Only a genuine USER action is subject to the auth gate. Ignore bot-authored
+    // updates and missing `from` (service noise) so we never ⛔-spam ourselves.
     if (!from || from.is_bot) return;
     const m = ctx.message ?? ctx.editedMessage;
-    if (m && (m.pinned_message || m.new_chat_members || m.left_chat_member)) return;
+    if (
+      m &&
+      (m.pinned_message ||
+        m.new_chat_members ||
+        m.left_chat_member ||
+        m.forum_topic_closed ||
+        m.forum_topic_reopened ||
+        m.forum_topic_edited ||
+        m.general_forum_topic_hidden ||
+        m.general_forum_topic_unhidden)
+    ) {
+      return;
+    }
 
-    const userId = String(from.id);
-    if (allowAll || cfg.allowedUsers.has(userId)) {
-      await next();
+    // forum_topic_created: only allowed users get the path-bind prompt.
+    if (m?.forum_topic_created) {
+      if (isAllowed(cfg, from.id)) {
+        await next();
+        return;
+      }
+      log.debug(`blocked unauthorized forum_topic_created from ${from.id}`);
       return;
     }
-    log.warn(`blocked unauthorized user ${userId}`);
-    if (ctx.chat) {
-      await ctx.reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID.");
+
+    if (isAllowed(cfg, from.id)) {
+      await next();
+      return;
     }
+
+    log.warn(
+      `blocked unauthorized user ${from.id}` +
+        (ctx.chat ? ` in chat ${ctx.chat.id} (${ctx.chat.type})` : ""),
+    );
+    await denyUnauthorized(ctx, m);
   };
 }
+
+/**
+ * True when ALLOWED_USERS was blank (open) or `userId` is listed.
+ * When allowAllUsers is false and the set is empty, nobody is allowed.
+ */
+export function isAllowed(cfg: AppConfig, userId: number | string): boolean {
+  if (cfg.allowAllUsers) return true;
+  return cfg.allowedUsers.has(String(userId));
+}
+
+/** Groups, supergroups, and channels: never ⛔-reply (silent deny). */
+function isGroupChat(ctx: Context): boolean {
+  const t = ctx.chat?.type;
+  return t === "group" || t === "supergroup" || t === "channel";
+}
+
+/** Private: one ⛔ reply. Group: silent (or callback toast). Never spam topics. */
+async function denyUnauthorized(
+  ctx: Context,
+  m: { message_thread_id?: number } | undefined,
+): Promise<void> {
+  if (ctx.callbackQuery) {
+    await ctx
+      .answerCallbackQuery({
+        text: "\u26D4 Not authorized",
+        show_alert: true,
+      })
+      .catch(() => {});
+    return;
+  }
+  if (!ctx.chat || isGroupChat(ctx)) return; // groups: ignore quietly
+  const threadId = m && "message_thread_id" in m ? m.message_thread_id : undefined;
+  const extra = threadId !== undefined ? { message_thread_id: threadId as number } : {};
+  await ctx
+    .reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID to ALLOWED_USERS.", extra)
+    .catch(() => {});
+}

package/src/bot/bot.ts

@@ -11,6 +11,7 @@ import { SettingsStore } from "../app/settings-store.js";
 import { SttService } from "../app/stt.js";
 import { Updater } from "../app/updater.js";
 import { UsageService } from "../app/usage.js";
+import { textPrompt } from "../app/types.js";
 import type { AppConfig } from "../config.js";
 import { INSTANCE_DIR } from "../config.js";
 import { createLogger } from "../logger.js";
@@ -21,11 +22,12 @@ 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 { COMMANDS, GROUP_COMMANDS } from "./commands.js";
 import { type BotDeps, MenuCache } from "./deps.js";
 import { registerControl } from "./handlers/control.js";
 import { registerDocuments } from "./handlers/document.js";
 import { registerHistory } from "./handlers/history.js";
+import { registerImportSession } from "./handlers/import-session.js";
 import { registerKill } from "./handlers/kill.js";
 import { registerMcp } from "./handlers/mcp.js";
 import { registerMenu } from "./handlers/menu.js";
@@ -41,6 +43,7 @@ import { registerSystem } from "./handlers/system.js";
 import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
 import { registerVoice } from "./handlers/voice.js";
+import { registerForum } from "./handlers/forum.js";
 import { StatusPanel } from "./menu/status-panel.js";
 import { sendMarkdownDoc } from "./telegram-io.js";
 import { Ephemeral } from "./menu/ephemeral.js";
@@ -48,6 +51,8 @@ import { BAR_LABELS } from "./menu/keyboard.js";
 import { PermissionService } from "./permission-service.js";
 import { RuntimeRegistry } from "./registry.js";
 import { TaskWizard } from "./wizard/task-wizard.js";
+import { ForumManager } from "../forum/manager.js";
+import { TelegramBotService } from "./telegram-bots.js";
 
 const log = createLogger("bot");
 
@@ -97,13 +102,44 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   const statusPanel = new StatusPanel(bot.api, settings, registry);
   registry.setRefresher((chatId) => void statusPanel.refresh(chatId));
 
+  const projects = new ProjectManager(cfg.projectRoots);
+  const forum =
+    cfg.topicGroupId !== undefined
+      ? new ForumManager(bot.api, cfg, projects)
+      : undefined;
+
+  // Sibling bots + memory/topic actions for the agent telegram JSON bridge.
+  const telegramBots = new TelegramBotService(bot.api, cfg);
+  telegramBots.attachToBot(bot);
+  registry.setBridge({
+    store,
+    forum,
+    bots: telegramBots,
+    // Cross-topic orchestration: General can create a topic and send_prompt there.
+    submitTopicPrompt: async ({ threadId, cwd, projectName, prompt, newSession }) => {
+      if (cfg.topicGroupId === undefined) {
+        throw new Error("TOPIC_GROUP_ID unset");
+      }
+      const groupId = cfg.topicGroupId;
+      const controller = registry.forumController(groupId, threadId, cwd, projectName);
+      if (newSession) {
+        const rt = await controller.addNew(cwd, projectName);
+        const outcome = await rt.submit(textPrompt(prompt));
+        return { outcome, sessionId: rt.sessionId };
+      }
+      const rt = controller.foreground();
+      const outcome = await rt.submit(textPrompt(prompt));
+      return { outcome, sessionId: rt.sessionId };
+    },
+  });
+
   const deps: BotDeps = {
     api: bot.api,
     cfg,
     acp,
     registry,
     store,
-    projects: new ProjectManager(cfg.projectRoots),
+    projects,
     menuCache: new MenuCache(),
     settings,
     statusPanel,
@@ -119,6 +155,7 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     }),
     usage: new UsageService(cfg.grokCliPath),
     accounts: new AccountManager(cfg.dataDir),
+    forum,
   };
 
   // Auto-rotate-on-give-up: let a stuck turn cycle through other saved logins.
@@ -133,6 +170,11 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     onUnpinned: (chatId) => statusPanel.ensurePinned(chatId),
   });
   acp.permissionHandler = (p) => permissions.handle(p);
+  // /stop and /cancel must cancel pending interactive permissions for that
+  // session only (ACP requires cancelled outcomes) — never kill the agent.
+  acp.onSessionCancel = (sessionId) => {
+    permissions.cancelForSession(sessionId);
+  };
 
   // The bot pins/unpins the status panel, and Telegram emits a "pinned a
   // message" service message for each pin. Delete those so the chat stays clean
@@ -144,14 +186,16 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   // 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.
+  // Keep history clean: delete the user's command (/…) and persistent-bar
+  // button taps INSTANTLY (before handlers) so slow ACP/CLI work never leaves
+  // the raw slash sitting in chat. Handlers post bot status messages instead.
+  // Plain prompts are adopted separately (see prompt-anchor.ts).
   bot.on("message:text", async (ctx, next) => {
-    await next();
     const text = ctx.message?.text ?? "";
     if (text.startsWith("/") || BAR_LABELS.includes(text)) {
-      await ctx.deleteMessage().catch(() => {});
+      void ctx.deleteMessage().catch(() => {});
     }
+    await next();
   });
 
   bot.callbackQuery(/^perm:(\d+):(\d+)$/, async (ctx) => {
@@ -171,11 +215,76 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     if (sid) await switchAndShow(ctx, deps, sid);
   });
 
+  // Legacy complexity buttons (removed — agent decides; auto-plan if complex).
+  bot.callbackQuery(/^cplx:(simple|complex)$/, async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Complexity is automatic now" });
+    await ctx
+      .editMessageText("\u2705 Complexity is decided by the agent automatically \u2014 just send your task.", {
+        reply_markup: { inline_keyboard: [] },
+      })
+      .catch(() => {});
+  });
+
+  // Post-turn suggestion buttons on the Done message.
+  bot.callbackQuery(/^sug:(\d+):(\d+)$/, async (ctx) => {
+    const batchId = Number(ctx.match![1]);
+    const index = Number(ctx.match![2]);
+    const { resolveScope } = await import("./scope.js");
+    const { adoptUserPrompt } = await import("./prompt-anchor.js");
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
+    const text = rt.takeSuggestion(batchId, index);
+    if (!text) {
+      await ctx.answerCallbackQuery({ text: "Suggestion expired", show_alert: true });
+      return;
+    }
+    await ctx.answerCallbackQuery({ text: "Sending\u2026" });
+    // Dim the keyboard so double-taps don't re-fire.
+    await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } }).catch(() => {});
+    try {
+      const chatId = ctx.chat?.id;
+      const anchor =
+        chatId !== undefined
+          ? await adoptUserPrompt(deps.api, {
+              chatId,
+              text,
+              userMessageIds: [],
+              messageThreadId: scope.threadExtra.message_thread_id,
+              projectName: rt.projectName,
+              prefix: "\u{1F4A1} Suggestion",
+            })
+          : undefined;
+      const outcome = await rt.submit(
+        textPrompt(text, anchor?.replyTo ?? ctx.callbackQuery.message?.message_id, undefined, {
+          promptId: anchor?.promptId,
+        }),
+      );
+      if (outcome === "queued") {
+        const extra: Record<string, unknown> = { ...scope.threadExtra };
+        if (anchor?.replyTo !== undefined) {
+          extra.reply_parameters = {
+            message_id: anchor.replyTo,
+            allow_sending_without_reply: true,
+          };
+        }
+        await ctx
+          .reply(`\u{1F4E5} Queued suggestion (position ${rt.queueLength}).`, extra)
+          .catch(() => {});
+      }
+    } catch (e) {
+      await ctx
+        .reply(`\u274C Couldn't run suggestion: ${(e as Error).message}`, scope.threadExtra)
+        .catch(() => {});
+    }
+  });
+
   registerMenu(bot, deps); // persistent-keyboard buttons (hears)
   registerWizardInput(bot, deps); // wizard text input (before commands)
+  if (forum) registerForum(bot, deps, forum);
   registerControl(bot, deps);
   registerProjects(bot, deps);
   registerSessions(bot, deps);
+  registerImportSession(bot, deps);
   registerSessionKill(bot, deps);
   registerRunning(bot, deps);
   registerHistory(bot, deps);
@@ -198,13 +307,40 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
       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);
+    const e = err.error;
+    if (e instanceof Error) {
+      // Include Grammy error_code when present (429 / 403 / 409, etc.) for diagnosis.
+      const codeNum = (e as unknown as { error_code?: number }).error_code;
+      const code = typeof codeNum === "number" ? ` (code ${codeNum})` : "";
+      log.error(`unhandled bot error${code}:`, e.stack || e.message);
+    } else {
+      log.error("unhandled bot error:", e);
+    }
+    // Never rethrow — a middleware failure must not take down long polling.
   });
 
-  try {
-    await bot.api.setMyCommands(COMMANDS);
-  } catch (e) {
-    log.warn("setMyCommands failed:", (e as Error).message);
+  // Scoped command menus: private = full sorted list; groups = short list with
+  // cancel/menu first (reply keyboard is unreliable in forum topics).
+  const registerCommands = async (
+    commands: typeof COMMANDS,
+    scope?: { type: string; chat_id?: number },
+    label = "default",
+  ): Promise<void> => {
+    try {
+      await bot.api.setMyCommands(commands, scope ? { scope: scope as never } : undefined);
+    } catch (e) {
+      log.warn(`setMyCommands (${label}) failed:`, (e as Error).message);
+    }
+  };
+  await registerCommands(COMMANDS, undefined, "default");
+  await registerCommands(COMMANDS, { type: "all_private_chats" }, "private");
+  await registerCommands(GROUP_COMMANDS, { type: "all_group_chats" }, "groups");
+  if (cfg.topicGroupId !== undefined) {
+    await registerCommands(
+      GROUP_COMMANDS,
+      { type: "chat", chat_id: cfg.topicGroupId },
+      `chat:${cfg.topicGroupId}`,
+    );
   }
 
   const updater = new Updater({
@@ -242,5 +378,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   // Remove any navigation surface left over from before a restart.
   void deps.ephemeral.cleanupAll().catch(() => {});
 
+  // Forum project topics: ensure AI Chat + optional catalog topics (best-effort).
+  if (forum) {
+    void forum.ensureSetup().catch((e) => {
+      log.warn(`forum setup failed: ${(e as Error).message}`);
+    });
+  }
+
   return { bot, registry, scheduler: new Scheduler(tasks, taskRunner), updater };
 }

package/src/bot/chat-controller.ts

@@ -23,6 +23,8 @@ export interface RunningSession {
   unread: number;
   /** Latest task-completion % (0–100) for this session, if known. */
   progress?: number;
+  /** Card comment: last user prompt (+ last AI thinking while busy). */
+  comment?: string;
 }
 
 export interface SwitchResult {
@@ -35,11 +37,31 @@ export interface SwitchResult {
   alreadyForeground: boolean;
 }
 
+export interface ChatControllerOpts {
+  /** Forum topic thread — all runtimes post into this topic. */
+  messageThreadId?: number;
+  /** Settings key (`chatId` or `chatId:t{thread}`). Defaults to String(chatId). */
+  settingsKey?: string;
+  /** Fixed project path (forum topics): never switch away via project picker. */
+  fixedCwd?: string;
+  fixedProjectName?: string;
+}
+
+/** Optional Telegram bridge services attached to every runtime in this chat. */
+export type ChatBridgeServices = SessionRuntime["bridge"];
+
 export class ChatController {
   private readonly runtimes: SessionRuntime[] = [];
   private fg: SessionRuntime | undefined;
   private readonly lastRead = new Map<string, number>();
   private restored = false;
+  readonly settingsKey: string;
+  readonly messageThreadId: number | undefined;
+  readonly fixedCwd: string | undefined;
+  readonly fixedProjectName: string | undefined;
+
+  /** Telegram bridge (forum / memory / sibling bots); set by the registry. */
+  bridge?: ChatBridgeServices;
 
   constructor(
     private readonly api: Api,
@@ -51,14 +73,22 @@ export class ChatController {
     private readonly refresh: (chatId: number) => void,
     private readonly notifyActivity: (busy: boolean) => void,
     private readonly getRotator?: () => AccountRotator | undefined,
-  ) {}
+    opts?: ChatControllerOpts,
+  ) {
+    this.messageThreadId = opts?.messageThreadId;
+    this.settingsKey = opts?.settingsKey ?? String(chatId);
+    this.fixedCwd = opts?.fixedCwd;
+    this.fixedProjectName = opts?.fixedProjectName;
+  }
 
   /** The current foreground runtime (created/restored lazily). */
   foreground(): SessionRuntime {
     this.ensureRestored();
     if (!this.fg) {
-      const s = this.settings.get(this.chatId);
-      const rt = this.create({ cwd: s.projectPath ?? this.cfg.workspace, projectName: s.projectName, sessionId: s.sessionId });
+      const s = this.settings.getKey(this.settingsKey);
+      const cwd = this.fixedCwd ?? s.projectPath ?? this.cfg.workspace;
+      const name = this.fixedProjectName ?? s.projectName;
+      const rt = this.create({ cwd, projectName: name, sessionId: s.sessionId });
       this.runtimes.push(rt);
       this.fg = rt;
     }
@@ -76,6 +106,7 @@ export class ChatController {
       foreground: rt.isForeground,
       unread: this.unreadCount(rt),
       progress: rt.taskProgress,
+      comment: rt.cardComment,
     }));
   }
 
@@ -142,6 +173,28 @@ export class ChatController {
     return rt;
   }
 
+  /**
+   * Import a foreign session (Kiro / OpenCode / Claude / Codex) as a new
+   * controlled Grok session in the same project, primed with the full transcript.
+   * The new session becomes the foreground /running entry.
+   */
+  async addImport(
+    cwd: string,
+    projectName: string | undefined,
+    priming: string,
+  ): Promise<SessionRuntime> {
+    this.ensureRestored();
+    const prevFg = this.fg;
+    const rt = this.create({ cwd, projectName });
+    this.runtimes.push(rt);
+    this.fg = rt;
+    void this.background(prevFg);
+    await rt.startImportedSession(cwd, projectName, priming);
+    this.markSeen(rt);
+    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.
@@ -251,6 +304,13 @@ export class ChatController {
     return this.runtimes.find((r) => r.sessionId === sessionId)?.taskProgress;
   }
 
+  /** Last user prompt (+ thinking when busy) for a controlled session id. */
+  commentFor(sessionId?: string): string | undefined {
+    if (!sessionId) return undefined;
+    this.ensureRestored();
+    return this.runtimes.find((r) => r.sessionId === sessionId)?.cardComment;
+  }
+
   findBySession(sessionId: string): boolean {
     return this.runtimes.some((r) => r.sessionId === sessionId);
   }
@@ -266,27 +326,31 @@ export class ChatController {
   private ensureRestored(): void {
     if (this.restored) return;
     this.restored = true;
-    const s = this.settings.get(this.chatId);
+    const s = this.settings.getKey(this.settingsKey);
     const seen = new Set<string>();
     for (const cs of s.controlledSessions ?? []) {
       if (!cs.sessionId || seen.has(cs.sessionId)) continue; // never restore the same session twice
       seen.add(cs.sessionId);
+      // Forum topics only restore sessions for the fixed project path.
+      if (this.fixedCwd && normPath(cs.projectPath) !== normPath(this.fixedCwd)) continue;
       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 homePath = this.fixedCwd ?? s.projectPath;
+    const homeName = this.fixedProjectName ?? s.projectName;
+    if (homePath) {
+      const key = normPath(homePath);
       const hasProject = this.runtimes.some((r) => normPath(r.cwd) === key);
       if (!hasProject) {
-        this.runtimes.push(this.create({ cwd: s.projectPath, projectName: s.projectName }));
+        this.runtimes.push(this.create({ cwd: homePath, projectName: homeName, sessionId: s.sessionId }));
       }
     }
     if (this.runtimes.length > 0) {
       let fg = this.runtimes.find((r) => r.sessionId && r.sessionId === s.foregroundSessionId);
-      if (!fg && s.projectPath) {
-        const key = normPath(s.projectPath);
+      if (!fg && homePath) {
+        const key = normPath(homePath);
         fg = this.runtimes.find((r) => normPath(r.cwd) === key);
       }
       fg = fg ?? this.runtimes[0]!;
@@ -330,10 +394,15 @@ export class ChatController {
   }
 
   private create(init: { cwd: string; projectName?: string; sessionId?: string }): SessionRuntime {
-    const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, init);
+    const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, {
+      ...init,
+      messageThreadId: this.messageThreadId,
+      settingsKey: this.settingsKey,
+    });
     rt.onStateChange = () => this.refresh(this.chatId);
     rt.onActivity = (busy) => this.notifyActivity(busy);
     rt.accountRotator = this.getRotator?.();
+    rt.bridge = this.bridge;
     // A logical fork (auto-fork-on-error / lost-session recovery) swaps the
     // runtime's session id in place — re-persist the controlled list with the
     // new id and treat the fresh session as already-seen.
@@ -380,15 +449,15 @@ export class ChatController {
       seen.add(r.sessionId);
       controlled.push({ sessionId: r.sessionId, projectPath: r.cwd, projectName: r.projectName });
     }
-    this.settings.update(this.chatId, {
+    this.settings.updateKey(this.settingsKey, {
       controlledSessions: controlled,
       foregroundSessionId: this.fg?.sessionId,
       // Keep the single-session restore fields aligned with the foreground so
       // the pinned status panel and a fresh restore never show a project that
       // belongs to a different (previously-foreground) session.
       sessionId: this.fg?.sessionId,
-      projectPath: this.fg?.cwd,
-      projectName: this.fg?.projectName,
+      projectPath: this.fixedCwd ?? this.fg?.cwd,
+      projectName: this.fixedProjectName ?? this.fg?.projectName,
     });
   }
 }