grok-telegram-bot 2.3.1 → 2.5.0

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,28 @@ export class StatusPanel {
     if (subagents) activity.push(`\u{1F465} ${subagents}`);
     lines.push(activity.join(SEP));
 
-    // 3) Where: project | session | context usage.
+    // 3b) Last user prompt (+ thinking while busy) — same source as Running cards.
+    // When a plan board is already shown above, still surface the user prompt;
+    // skip only a pure thinking second line if plan is active (less noise).
+    const comment = rt.cardComment;
+    if (comment) {
+      const parts = comment.split("\n").map((l) => l.trim()).filter(Boolean);
+      const hideThinking = !!(rt.planSummary && rt.isBusy);
+      parts.forEach((part, i) => {
+        if (hideThinking && i > 0) return;
+        const icon = i === 0 ? (rt.isBusy ? "\u23F3" : "\u{1F4AC}") : "\u{1F9E0}";
+        const shown = part.length > 250 ? `${part.slice(0, 249)}\u2026` : part;
+        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/permission-service.ts

@@ -161,6 +161,25 @@ export class PermissionService {
     return this.pending.get(reqId)?.sessionId;
   }
 
+  /**
+   * ACP: when a session is cancelled, all pending permission requests for that
+   * session must complete with `cancelled`. Returns how many were cancelled.
+   * Does not touch other sessions.
+   */
+  cancelForSession(sessionId: string): number {
+    let n = 0;
+    for (const [reqId, p] of [...this.pending.entries()]) {
+      if (p.sessionId !== sessionId) continue;
+      clearTimeout(p.timer);
+      this.pending.delete(reqId);
+      void this.finishPrompt(p, "\u{1F510} (cancelled — turn stopped)");
+      p.resolve({ outcome: { outcome: "cancelled" } });
+      n++;
+    }
+    if (n > 0) log.info(`cancelled ${n} pending permission(s) for session ${sessionId.slice(0, 8)}`);
+    return n;
+  }
+
   /** Unpin (if pinned) and optionally rewrite the prompt message. */
   private async finishPrompt(p: Pending, text?: string): Promise<void> {
     if (p.messageId !== undefined && text) {

package/src/bot/prompt-anchor.ts

@@ -0,0 +1,300 @@
+/**
+ * Prompt anchors & command acks — instant bot feedback while the CLI/ACP warms up.
+ *
+ * When the user sends a prompt we:
+ *   1. post a bot-owned message with the prompt text + `#prompt_<id>`
+ *      (and re-attach any photos/files/voice so media is not lost when the
+ *      user's original is deleted)
+ *   2. best-effort delete the user's original message(s)
+ *   3. thread every AI reply (and Done/error) to that bot message
+ *
+ * Commands use {@link ackCommand}: delete the slash message immediately and
+ * post a short status so the chat never looks dead during slow handlers.
+ */
+import type { Api, Context } from "grammy";
+import { InputMediaBuilder } from "grammy";
+import { createLogger } from "../logger.js";
+import { tagSafe } from "../render/hashtags.js";
+
+const log = createLogger("prompt-anchor");
+
+/** Telegram hard cap for text messages; leave room for prefix + tags. */
+const BODY_BUDGET = 3800;
+/** Telegram caption hard cap on photo/document/audio/video. */
+const CAPTION_BUDGET = 1024;
+
+export type AdoptMediaItem =
+  | { type: "photo"; fileId: string }
+  | { type: "document"; fileId: string; fileName?: string }
+  | { type: "voice"; fileId: string }
+  | { type: "audio"; fileId: string; fileName?: string }
+  | { type: "video"; fileId: string }
+  | { type: "video_note"; fileId: string };
+
+export interface AdoptPromptOpts {
+  chatId: number;
+  /** User prompt body to echo on the anchor (not sent to the agent twice — agent gets original text). */
+  text: string;
+  /** User Telegram message ids to delete after the anchor is posted. */
+  userMessageIds: number[];
+  messageThreadId?: number;
+  projectName?: string;
+  /** Leading emoji/label, e.g. "📝", "📷", "🎤". */
+  prefix?: string;
+  /**
+   * Media from the user's message(s), re-posted via Telegram file_id so the
+   * chat keeps images/files after the original is deleted. Same bot may reuse
+   * file_ids it received.
+   */
+  media?: AdoptMediaItem[];
+}
+
+export interface PromptAnchor {
+  /** Bot message id — use as PromptInput.replyTo. */
+  replyTo: number;
+  /** Short id for `#prompt_<id>` footers. */
+  promptId: string;
+}
+
+/** Short unique id safe for Telegram hashtag bodies. */
+export function newPromptId(): string {
+  const t = Date.now().toString(36);
+  const r = Math.random().toString(36).slice(2, 6);
+  return tagSafe(`${t}${r}`);
+}
+
+export function formatPromptTag(promptId: string): string {
+  return `#prompt_${tagSafe(promptId)}`;
+}
+
+/** Build the plain-text body of a prompt-anchor message (hashtags stay tappable). */
+export function formatPromptAnchorBody(
+  text: string,
+  promptId: string,
+  opts?: { prefix?: string; projectName?: string },
+): string {
+  const prefix = (opts?.prefix ?? "\u{1F4DD}").trim();
+  const body = truncateBody(text.trim() || "(empty)", BODY_BUDGET);
+  const tags = [formatPromptTag(promptId)];
+  if (opts?.projectName?.trim()) {
+    tags.push(`#proj_${tagSafe(opts.projectName)}`);
+  }
+  return `${prefix}\n${body}\n\n${tags.join(" ")}`;
+}
+
+/**
+ * Fit anchor body into a media caption (1024). Prefer keeping the trailing
+ * hashtag line so `#prompt_` stays searchable — never slice tags off the end.
+ */
+export function fitCaption(body: string, max = CAPTION_BUDGET): string {
+  if (body.length <= max) return body;
+  const lines = body.split("\n");
+  const last = (lines[lines.length - 1] ?? "").trim();
+  const tags = last.includes("#prompt_") ? last : "";
+  if (tags) {
+    // Reserve room for "\n…\n\n" + tags; never clip the tag line.
+    const sep = "\n\u2026\n\n";
+    const budget = max - tags.length - sep.length;
+    if (budget > 40) {
+      const cutAt = body.lastIndexOf(tags);
+      const rawHead = (cutAt > 0 ? body.slice(0, cutAt) : body).replace(/\s+$/, "");
+      const head = rawHead.length > budget ? rawHead.slice(0, budget) : rawHead;
+      return `${head}${sep}${tags}`;
+    }
+    // Tags alone almost fill the caption — keep tags only.
+    return tags.length <= max ? tags : tags.slice(0, max - 1) + "\u2026";
+  }
+  return body.slice(0, max - 1) + "\u2026";
+}
+
+/**
+ * Post a bot-owned prompt message (with media when provided), delete the user's
+ * original(s), return ids for threading + tagging. On send failure returns
+ * undefined (caller falls back).
+ */
+export async function adoptUserPrompt(
+  api: Api,
+  opts: AdoptPromptOpts,
+): Promise<PromptAnchor | undefined> {
+  const promptId = newPromptId();
+  const body = formatPromptAnchorBody(opts.text, promptId, {
+    prefix: opts.prefix,
+    projectName: opts.projectName,
+  });
+  const threadExtra: Record<string, unknown> = {
+    disable_notification: true,
+  };
+  if (opts.messageThreadId !== undefined) {
+    threadExtra.message_thread_id = opts.messageThreadId;
+  }
+
+  let replyTo: number;
+  try {
+    const media = (opts.media ?? []).filter((m) => !!m.fileId);
+    if (media.length > 0) {
+      replyTo = await sendAnchorWithMedia(api, opts.chatId, media, body, threadExtra);
+    } else {
+      const msg = await api.sendMessage(opts.chatId, body, threadExtra);
+      replyTo = msg.message_id;
+    }
+  } catch (err) {
+    log.warn(`anchor send failed chat=${opts.chatId}: ${(err as Error).message}`);
+    // Fallback: text-only anchor so threading still works if media re-post fails.
+    try {
+      const msg = await api.sendMessage(opts.chatId, body, threadExtra);
+      replyTo = msg.message_id;
+    } catch (err2) {
+      log.warn(`anchor text fallback failed chat=${opts.chatId}: ${(err2 as Error).message}`);
+      return undefined;
+    }
+  }
+
+  await deleteUserMessages(api, opts.chatId, opts.userMessageIds);
+  return { replyTo, promptId };
+}
+
+/** Re-post user media with caption/tags so files remain in chat history. */
+async function sendAnchorWithMedia(
+  api: Api,
+  chatId: number,
+  media: AdoptMediaItem[],
+  body: string,
+  threadExtra: Record<string, unknown>,
+): Promise<number> {
+  const caption = fitCaption(body);
+  const needsFollowUp = body.length > CAPTION_BUDGET;
+
+  // Photo album: one media group (caption on first only).
+  if (media.length > 1 && media.every((m) => m.type === "photo")) {
+    const group = media.map((m, i) =>
+      i === 0
+        ? InputMediaBuilder.photo(m.fileId, { caption })
+        : InputMediaBuilder.photo(m.fileId),
+    );
+    const msgs = await api.sendMediaGroup(chatId, group, threadExtra);
+    const firstId = msgs[0]?.message_id;
+    if (firstId === undefined) throw new Error("sendMediaGroup returned no messages");
+    if (needsFollowUp) {
+      await api
+        .sendMessage(chatId, body, {
+          ...threadExtra,
+          reply_parameters: { message_id: firstId, allow_sending_without_reply: true },
+        })
+        .catch(() => {});
+    }
+    return firstId;
+  }
+
+  // Single (or primary) media item; extra photos sent as a follow-up group.
+  const primary = media[0]!;
+  const restPhotos = media.slice(1).filter((m): m is Extract<AdoptMediaItem, { type: "photo" }> => m.type === "photo");
+
+  let replyTo: number;
+  const capOpts = { caption, ...threadExtra };
+
+  switch (primary.type) {
+    case "photo": {
+      const msg = await api.sendPhoto(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "document": {
+      const msg = await api.sendDocument(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "voice": {
+      const msg = await api.sendVoice(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "audio": {
+      const msg = await api.sendAudio(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "video": {
+      const msg = await api.sendVideo(chatId, primary.fileId, capOpts);
+      replyTo = msg.message_id;
+      break;
+    }
+    case "video_note": {
+      // video_note has no caption — post note then text anchor as reply.
+      const msg = await api.sendVideoNote(chatId, primary.fileId, threadExtra);
+      replyTo = msg.message_id;
+      await api
+        .sendMessage(chatId, body, {
+          ...threadExtra,
+          reply_parameters: { message_id: replyTo, allow_sending_without_reply: true },
+        })
+        .catch(() => {});
+      return replyTo;
+    }
+    default: {
+      const msg = await api.sendMessage(chatId, body, threadExtra);
+      return msg.message_id;
+    }
+  }
+
+  if (restPhotos.length > 0) {
+    const group = restPhotos.map((m) => InputMediaBuilder.photo(m.fileId));
+    await api.sendMediaGroup(chatId, group, threadExtra).catch((e) => {
+      log.debug(`extra photo group failed: ${(e as Error).message}`);
+    });
+  }
+
+  if (needsFollowUp) {
+    await api
+      .sendMessage(chatId, body, {
+        ...threadExtra,
+        reply_parameters: { message_id: replyTo, allow_sending_without_reply: true },
+      })
+      .catch(() => {});
+  }
+
+  return replyTo;
+}
+
+/** Best-effort delete of user messages (private chats may refuse). */
+export async function deleteUserMessages(
+  api: Api,
+  chatId: number,
+  messageIds: number[],
+): Promise<void> {
+  const unique = [...new Set(messageIds.filter((id) => Number.isFinite(id) && id > 0))];
+  await Promise.all(
+    unique.map(async (id) => {
+      try {
+        await api.deleteMessage(chatId, id);
+      } catch {
+        /* no rights / already gone / too old — non-fatal */
+      }
+    }),
+  );
+}
+
+/**
+ * Instant command feedback: delete the user's command and post a bot status.
+ * Fire-and-forget delete so slow work never waits on Telegram cleanup.
+ */
+export async function ackCommand(
+  ctx: Context,
+  text: string,
+  extra: Record<string, unknown> = {},
+): Promise<number | undefined> {
+  void ctx.deleteMessage().catch(() => {});
+  try {
+    const msg = await ctx.reply(text, extra);
+    return msg.message_id;
+  } catch (err) {
+    log.debug(`ackCommand reply failed: ${(err as Error).message}`);
+    return undefined;
+  }
+}
+
+function truncateBody(text: string, max: number): string {
+  if (text.length <= max) return text;
+  const head = Math.floor(max * 0.7);
+  const tail = max - head - 5;
+  return `${text.slice(0, head)}\n\u2026\n${text.slice(-tail)}`;
+}

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)
@@ -74,7 +77,11 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
     images: inputs.flatMap((i) => i.images),
     resourceLinks: inputs.flatMap((i) => i.resourceLinks ?? []),
     replyTo: inputs.find((i) => i.replyTo !== undefined)?.replyTo,
+    // First prompt's id wins (same rule as replyTo) so merged queue turns keep
+    // one searchable #prompt_ tag threaded to the first anchor.
+    promptId: inputs.find((i) => i.promptId)?.promptId,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
+    skipSelfRecheck: skipSelfRecheck || undefined,
   };
 }
 

package/src/bot/registry.ts

@@ -18,7 +18,7 @@ import type { AppConfig } from "../config.js";
 import { subagentSummary } from "../render/subagent.js";
 import type { SessionStore } from "../sessions/store.js";
 import type { AccountRotator } from "./account-rotator.js";
-import { ChatController } from "./chat-controller.js";
+import { ChatController, type ChatBridgeServices } from "./chat-controller.js";
 import type { SessionRuntime } from "./session-runtime.js";
 
 export interface SessionDescription {
@@ -34,8 +34,14 @@ export interface SessionDescription {
 
 export class RuntimeRegistry {
   private readonly controllers = new Map<number, ChatController>();
+  /**
+   * Forum topic controllers keyed by `chatId:threadId`.
+   * Each topic has its own multi-session controller + settings (model/reasoning).
+   */
+  private readonly forumControllers = new Map<string, ChatController>();
   private refresher: ((chatId: number) => void) | undefined;
   private rotator: AccountRotator | undefined;
+  private bridge: ChatBridgeServices | undefined;
   /** Chat ids with a running turn, most-recently-started last. */
   private readonly activeChats: number[] = [];
   /** Subagent sessionId -> owner chat id. */
@@ -60,6 +66,13 @@ export class RuntimeRegistry {
     this.rotator = rotator;
   }
 
+  /** Telegram bridge services (forum, session store, sibling bots). */
+  setBridge(bridge: ChatBridgeServices): void {
+    this.bridge = bridge;
+    for (const c of this.controllers.values()) c.bridge = bridge;
+    for (const c of this.forumControllers.values()) c.bridge = bridge;
+  }
+
   controller(chatId: number): ChatController {
     let c = this.controllers.get(chatId);
     if (!c) {
@@ -74,6 +87,7 @@ export class RuntimeRegistry {
         (busy) => this.noteActivity(chatId, busy),
         () => this.rotator,
       );
+      c.bridge = this.bridge;
       this.controllers.set(chatId, c);
     }
     return c;
@@ -84,9 +98,78 @@ export class RuntimeRegistry {
     return this.controller(chatId).foreground();
   }
 
+  /**
+   * Multi-session controller for a forum topic (fixed project path).
+   * Settings key: `{chatId}:t{threadId}` — own model / reasoning / sessions.
+   */
+  forumController(
+    chatId: number,
+    threadId: number,
+    cwd: string,
+    projectName?: string,
+  ): ChatController {
+    const key = `${chatId}:${threadId}`;
+    let c = this.forumControllers.get(key);
+    if (c && c.fixedCwd && normPath(c.fixedCwd) !== normPath(cwd)) {
+      // Path re-bind — dispose and recreate.
+      c.dispose();
+      this.forumControllers.delete(key);
+      c = undefined;
+    }
+    if (!c) {
+      c = new ChatController(
+        this.api,
+        chatId,
+        this.acp,
+        this.cfg,
+        this.settings,
+        this.store,
+        (id) => this.refresher?.(id),
+        (busy) => this.noteActivity(chatId, busy),
+        () => this.rotator,
+        {
+          messageThreadId: threadId,
+          settingsKey: `${chatId}:t${threadId}`,
+          fixedCwd: cwd,
+          fixedProjectName: projectName,
+        },
+      );
+      c.bridge = this.bridge;
+      this.forumControllers.set(key, c);
+    }
+    return c;
+  }
+
+  /**
+   * Foreground runtime for a forum topic. Creates the topic controller lazily.
+   */
+  getForumTopic(
+    chatId: number,
+    threadId: number,
+    cwd: string,
+    projectName?: string,
+  ): SessionRuntime {
+    return this.forumController(chatId, threadId, cwd, projectName).foreground();
+  }
+
+  /** All forum topic controllers (for bidirectional session listing). */
+  allForumControllers(): ChatController[] {
+    return [...this.forumControllers.values()];
+  }
+
+  /** Forum controller that currently owns a session id, if any. */
+  forumControllerForSession(sessionId: string): ChatController | undefined {
+    for (const c of this.forumControllers.values()) {
+      if (c.findBySession(sessionId)) return c;
+    }
+    return undefined;
+  }
+
   disposeAll(): void {
     for (const c of this.controllers.values()) c.dispose();
     this.controllers.clear();
+    for (const c of this.forumControllers.values()) c.dispose();
+    this.forumControllers.clear();
   }
 
   /** Find the chat that currently controls a given session id. */
@@ -94,6 +177,12 @@ export class RuntimeRegistry {
     for (const [chatId, c] of this.controllers) {
       if (c.findBySession(sessionId)) return chatId;
     }
+    for (const [key, c] of this.forumControllers) {
+      if (c.findBySession(sessionId)) {
+        const chatId = Number(key.split(":")[0]);
+        return Number.isFinite(chatId) ? chatId : undefined;
+      }
+    }
     return undefined;
   }
 
@@ -184,3 +273,7 @@ export class RuntimeRegistry {
     }
   }
 }
+
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}

package/src/bot/scope.ts

@@ -0,0 +1,94 @@
+/**
+ * Resolve private-chat vs forum-topic scope for handlers (menu, running, sessions).
+ * Forum topics use a dedicated ChatController with per-topic settings + sessions.
+ */
+import type { Context } from "grammy";
+import type { BotDeps } from "./deps.js";
+import type { ChatController } from "./chat-controller.js";
+import type { SessionRuntime } from "./session-runtime.js";
+import { forumThreadId } from "../forum/thread.js";
+import { FORUM_GENERAL_THREAD_ID } from "../forum/thread.js";
+
+export interface HandlerScope {
+  chatId: number;
+  /** Forum message_thread_id when in the configured topic group. */
+  threadId?: number;
+  isForum: boolean;
+  /** Settings key for this scope (chat or chat:t{thread}). */
+  settingsKey: string;
+  controller: ChatController;
+  /** Foreground runtime for this scope. */
+  rt: SessionRuntime;
+  /** Extra fields so replies land in the same topic. */
+  threadExtra: { message_thread_id?: number };
+  /** Project path when forum topic is bound. */
+  projectPath?: string;
+  projectName?: string;
+}
+
+/** Build settings storage key. */
+export function settingsKeyFor(chatId: number, threadId?: number): string {
+  if (threadId === undefined) return String(chatId);
+  return `${chatId}:t${threadId}`;
+}
+
+/** Extract thread id from message or callback message. */
+export function threadIdFromContext(ctx: Context): number | undefined {
+  const msg = ctx.message ?? ctx.callbackQuery?.message;
+  if (!msg || !("message_thread_id" in msg)) return undefined;
+  const tid = (msg as { message_thread_id?: number }).message_thread_id;
+  return typeof tid === "number" ? tid : undefined;
+}
+
+/**
+ * Resolve handler scope. For the forum group, ensures topic binding (General →
+ * workspace) and returns the topic's ChatController + foreground runtime.
+ */
+export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
+  const chatId = ctx.chat!.id;
+  const rawThread = threadIdFromContext(ctx);
+  const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+  const threadExtra =
+    isForum || rawThread !== undefined
+      ? { message_thread_id: isForum ? forumThreadId(rawThread) : rawThread }
+      : {};
+
+  if (!isForum || !deps.forum) {
+    const controller = deps.registry.controller(chatId);
+    return {
+      chatId,
+      isForum: false,
+      settingsKey: settingsKeyFor(chatId),
+      controller,
+      rt: controller.foreground(),
+      threadExtra: rawThread !== undefined ? { message_thread_id: rawThread } : {},
+    };
+  }
+
+  const tid = forumThreadId(rawThread);
+  // Ensure General / AI paths are bound before opening menus.
+  if (tid === FORUM_GENERAL_THREAD_ID) {
+    if (!deps.forum.store.get(tid)?.projectPath) {
+      deps.forum.store.bindProject(tid, deps.cfg.workspace, "General", "general");
+    }
+  }
+  const resolved = deps.forum.resolveCwd(tid);
+  const cwd = resolved?.cwd ?? deps.cfg.workspace;
+  const projectName = resolved?.projectName ?? (tid === FORUM_GENERAL_THREAD_ID ? "General" : `Topic ${tid}`);
+  if (!resolved && tid !== FORUM_GENERAL_THREAD_ID) {
+    // Unbound topic — still allow menu with workspace fallback for prefs; path
+    // bind happens on next text message via resolveForumRuntime.
+  }
+  const controller = deps.registry.forumController(chatId, tid, cwd, projectName);
+  return {
+    chatId,
+    threadId: tid,
+    isForum: true,
+    settingsKey: settingsKeyFor(chatId, tid),
+    controller,
+    rt: controller.foreground(),
+    threadExtra: { message_thread_id: tid },
+    projectPath: cwd,
+    projectName,
+  };
+}

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.";