grok-telegram-bot 2.5.0 → 2.6.0

package/src/bot/group-memory.ts

@@ -2,6 +2,9 @@
  * Local "group memory" search across forum topics, session metadata, and
  * recent session history. Telegram bots have no general message-search API,
  * so this indexes what the bridge already stores on disk.
+ *
+ * Ranking is **relevance + recency**: newer sessions / history win over old
+ * matching text so "what was last worked on" does not surface stale Done notes.
  */
 import { join } from "node:path";
 import { readHistory } from "../sessions/history.js";
@@ -19,6 +22,8 @@ export interface MemoryHit {
   path?: string;
   sessionId?: string;
   threadId?: number;
+  /** Epoch ms for secondary sort / display (session or entry time). */
+  at?: number;
 }
 
 export interface GroupMemorySearchOpts {
@@ -29,6 +34,13 @@ export interface GroupMemorySearchOpts {
   topics?: ForumTopicBinding[];
   /** Max sessions whose JSONL tails are scanned. */
   maxSessions?: number;
+  /**
+   * Prefer sessions under these paths (e.g. workspace for General, then a
+   * project path). Earlier paths get a higher score boost.
+   */
+  preferPaths?: string[];
+  /** Boost history from sessions whose title/comment looks like General manager. */
+  preferGeneral?: boolean;
 }
 
 /** Tokenize a query into lowercase alphanumeric tokens (min length 2). */
@@ -62,72 +74,208 @@ export function scoreTokens(haystack: string, tokens: string[]): number {
   return score;
 }
 
+/**
+ * True when the user is asking what happened *recently* (last mods, last work).
+ * These queries weight recency much higher than pure text match.
+ * Avoid bare "work"/"done" — those appear in many normal asks and would
+ * over-prioritize recency over relevance.
+ */
+export function queryWantsRecency(query: string): boolean {
+  return /\b(last|latest|recent|newest|today|yesterday|modif(?:y|ied|ication|ications)?|changes?|changed|updated|what\s+was|what\s+did|last\s+work|recent\s+work|last\s+done)\b/i.test(
+    query,
+  );
+}
+
+/**
+ * Normalize epoch seconds vs milliseconds (or ISO string) to ms.
+ * Returns undefined when missing/invalid (never NaN).
+ */
+export function normalizeEpochMs(
+  value: string | number | undefined,
+): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  let t: number;
+  if (typeof value === "number") {
+    t = value;
+  } else {
+    t = Date.parse(value);
+  }
+  if (!Number.isFinite(t) || t <= 0) return undefined;
+  // Seconds since epoch (~1e9) → ms. ms since epoch is ~1e12+.
+  if (t > 0 && t < 1e11) t *= 1000;
+  if (!Number.isFinite(t) || t <= 0) return undefined;
+  return t;
+}
+
+/**
+ * Recency score 0–20 from an updatedAt ISO string or epoch ms/seconds.
+ * <1h:20, <6h:16, <24h:12, <3d:8, <7d:4, <30d:2, older:0.
+ */
+export function recencyBoost(updatedAt: string | number | undefined, now = Date.now()): number {
+  const t = normalizeEpochMs(updatedAt);
+  if (t === undefined) return 0;
+  const ageH = Math.max(0, (now - t) / 3_600_000);
+  if (ageH < 1) return 20;
+  if (ageH < 6) return 16;
+  if (ageH < 24) return 12;
+  if (ageH < 72) return 8;
+  if (ageH < 168) return 4;
+  if (ageH < 720) return 2;
+  return 0;
+}
+
+/** Human-ish age for snippets. */
+export function formatAge(at: number | undefined, now = Date.now()): string {
+  if (!at || !Number.isFinite(at)) return "";
+  const mins = Math.max(0, Math.round((now - at) / 60_000));
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.round(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+
 /**
  * Search topics + session store + recent history. Pure ranking over provided
  * store; safe to call on the main bot thread (capped I/O).
+ *
+ * Sort key: score (relevance + recency) DESC, then `at` DESC (newest first).
  */
 export function searchGroupMemory(opts: GroupMemorySearchOpts): MemoryHit[] {
   const tokens = tokenizeQuery(opts.query);
   if (tokens.length === 0) return [];
   const limit = Math.max(1, Math.min(20, opts.limit ?? 8));
   const maxSessions = opts.maxSessions ?? 40;
+  const now = Date.now();
+  const wantsRecent = queryWantsRecency(opts.query);
+  /** Multiply recency when user asks for last/recent work. */
+  const recencyMul = wantsRecent ? 2.5 : 1.2;
   const hits: MemoryHit[] = [];
 
   for (const t of opts.topics ?? []) {
     const hay = [t.name, t.projectPath ?? "", t.kind, t.sessionId ?? ""].join("\n");
     const score = scoreTokens(hay, tokens);
     if (score <= 0) continue;
+    // Topic map updatedAt is already epoch ms.
+    const at = normalizeEpochMs(t.updatedAt);
+    // Mild recency on topics (routing), not full "last work" weight.
+    const r = recencyBoost(at, now) * Math.min(1.2, recencyMul);
     hits.push({
       kind: "topic",
       title: t.name,
       snippet: t.projectPath ? `path: ${t.projectPath}` : `kind: ${t.kind}`,
-      score: score + 2, // slight boost for topic map
+      score: score + 2 + r,
       path: t.projectPath ?? undefined,
       threadId: t.threadId,
       sessionId: t.sessionId,
+      at,
     });
   }
 
   let metas: SessionMeta[] = [];
   try {
+    // Store already returns most-recently-updated first.
     metas = opts.store.list(maxSessions);
   } catch {
     metas = [];
   }
 
+  const prefer = (opts.preferPaths ?? []).map((p) => p.replace(/\\/g, "/").toLowerCase());
+
+  // Per project path: which session is the newest (for "last work in X").
+  const newestByCwd = new Map<string, number>();
   for (const m of metas) {
+    const key = normPath(m.cwd);
+    if (!key) continue;
+    const t = normalizeEpochMs(m.updatedAt) ?? 0;
+    const prev = newestByCwd.get(key) ?? 0;
+    if (t > prev) newestByCwd.set(key, t);
+  }
+
+  for (const m of metas) {
+    const pathBoost = pathPreferenceBoost(m.cwd, prefer);
+    const generalBoost =
+      opts.preferGeneral &&
+      (/^general$/i.test(m.title || "") || /general/i.test(m.comment || ""))
+        ? 5
+        : 0;
+    const sessionAt = normalizeEpochMs(m.updatedAt);
+    const rBoost = recencyBoost(sessionAt, now) * recencyMul;
+    const newestBoost =
+      sessionAt !== undefined && newestByCwd.get(normPath(m.cwd)) === sessionAt ? 10 : 0;
+
     const hay = [m.title, m.comment ?? "", m.cwd, m.sessionId].join("\n");
-    const score = scoreTokens(hay, tokens);
-    if (score > 0) {
+    const base = scoreTokens(hay, tokens);
+    // Require text relevance — path/recency alone never invents a hit.
+    if (base <= 0) {
+      // Still scan history below if the session might contain matching tails.
+    }
+    const score = base + pathBoost + generalBoost + rBoost + newestBoost;
+    const age = formatAge(sessionAt, now);
+
+    if (base > 0 && Number.isFinite(score) && score > 0) {
       hits.push({
         kind: "session",
         title: m.title || m.sessionId.slice(0, 8),
         snippet: clamp(
-          [m.comment, m.cwd].filter(Boolean).join(" · ") || m.sessionId,
-          220,
+          [age ? `[${age}]` : "", m.comment, m.cwd].filter(Boolean).join(" · ") || m.sessionId,
+          240,
         ),
         score,
         path: m.cwd || undefined,
         sessionId: m.sessionId,
+        at: sessionAt,
       });
     }
 
-    // History tail (cheap): few entries, short text.
+    // History: deeper tail for recent or path-matched sessions.
+    const histDepth =
+      rBoost >= 12 || pathBoost + generalBoost > 0 || wantsRecent ? 28 : 14;
     if (m.historyBytes <= 0) continue;
     try {
       const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
-      const entries = readHistory(path, 12);
-      for (const e of entries) {
+      const entries = readHistory(path, histDepth);
+      // Prefer newer entries: history is oldest→newest; weight later indices.
+      const n = entries.length;
+      for (let i = 0; i < n; i++) {
+        const e = entries[i]!;
         if (!e.text?.trim()) continue;
-        const s = scoreTokens(e.text, tokens);
-        if (s <= 0) continue;
+        // Skip meta dumps that pollute "last work" answers.
+        if (/MANAGER CONTEXT \(auto/i.test(e.text)) continue;
+        if (/^COMPLEXITY \(decide yourself/i.test(e.text)) continue;
+        if (/TELEGRAM BRIDGE \(how to work/i.test(e.text)) continue;
+
+        const textScore = scoreTokens(e.text, tokens);
+        if (textScore <= 0) continue;
+
+        // Prefer entry timestamp; fall back to session updatedAt (not 0/NaN).
+        const entryAt = normalizeEpochMs(e.timestamp) ?? sessionAt;
+        const entryRecency = recencyBoost(entryAt, now) * recencyMul;
+        // Position boost: last entries in the tail are newest.
+        const posBoost = n > 1 ? Math.round((i / (n - 1)) * 6) : 3;
+        // Prefer user prompts + assistant Done prose for "what was last done".
+        const roleBoost = e.role === "user" ? 3 : e.role === "assistant" ? 3 : 0;
+        const s =
+          textScore +
+          pathBoost +
+          generalBoost +
+          entryRecency +
+          posBoost +
+          roleBoost +
+          (newestBoost > 0 ? 4 : 0);
+        if (!Number.isFinite(s) || s <= 0) continue;
+        const eAge = formatAge(entryAt, now);
         hits.push({
           kind: "history",
           title: `${e.role} · ${(m.title || m.sessionId.slice(0, 8)).slice(0, 40)}`,
-          snippet: clamp(e.text.replace(/\s+/g, " ").trim(), 220),
+          snippet: clamp(
+            [eAge ? `[${eAge}]` : "", e.text.replace(/\s+/g, " ").trim()].filter(Boolean).join(" "),
+            240,
+          ),
           score: s,
           path: m.cwd || undefined,
           sessionId: m.sessionId,
+          at: entryAt,
         });
       }
     } catch {
@@ -135,7 +283,13 @@ export function searchGroupMemory(opts: GroupMemorySearchOpts): MemoryHit[] {
     }
   }
 
-  hits.sort((a, b) => b.score - a.score || a.kind.localeCompare(b.kind));
+  // Newest high scores first.
+  hits.sort(
+    (a, b) =>
+      b.score - a.score ||
+      (b.at ?? 0) - (a.at ?? 0) ||
+      a.kind.localeCompare(b.kind),
+  );
   // Dedupe near-identical snippets.
   const seen = new Set<string>();
   const out: MemoryHit[] = [];
@@ -157,3 +311,29 @@ function clamp(s: string, max: number): string {
 function escapeReg(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+function normPath(p: string | undefined): string {
+  if (!p) return "";
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+
+/**
+ * Higher boost for earlier preferred paths.
+ * Index 0 is usually the workspace (General) — use **exact** match only so we
+ * do not treat every child project under Domains as "General memory".
+ * Later entries (project paths) allow prefix match.
+ */
+function pathPreferenceBoost(cwd: string | undefined, prefer: string[]): number {
+  if (!cwd || prefer.length === 0) return 0;
+  const n = cwd.replace(/\\/g, "/").toLowerCase();
+  for (let i = 0; i < prefer.length; i++) {
+    const p = prefer[i]!.replace(/\\/g, "/").toLowerCase();
+    if (!p) continue;
+    const exact = n === p;
+    const child = i > 0 && (n === p || n.startsWith(p + "/"));
+    if (exact || child) {
+      return 8 - Math.min(6, i * 2);
+    }
+  }
+  return 0;
+}

package/src/bot/handlers/forum.ts

@@ -5,7 +5,11 @@ import type { Bot } from "grammy";
 import { createLogger } from "../../logger.js";
 import type { ForumManager } from "../../forum/manager.js";
 import type { BotDeps } from "../deps.js";
-import { FORUM_GENERAL_THREAD_ID, forumThreadId } from "../../forum/thread.js";
+import {
+  FORUM_GENERAL_THREAD_ID,
+  forumThreadId,
+  outboundThreadExtra,
+} from "../../forum/thread.js";
 
 const log = createLogger("forum-handler");
 
@@ -89,8 +93,7 @@ export function registerForum(bot: Bot, deps: BotDeps, forum: ForumManager): voi
   // Optional: re-run setup command for admins in the group.
   bot.command("forum_setup", async (ctx) => {
     const threadId = ctx.message?.message_thread_id;
-    const replyOpts =
-      threadId !== undefined ? { message_thread_id: threadId } : {};
+    const replyOpts = outboundThreadExtra(threadId);
     if (ctx.chat?.id !== groupId) {
       await ctx.reply("Use this command inside the configured forum group.", replyOpts).catch(() => {});
       return;
@@ -167,7 +170,11 @@ export async function resolveForumRuntime(
         .sendMessage(
           chatId,
           `\u2705 Bound to project:\n\`${result.binding.projectPath}\`${iconNote}\n\nYou can chat here now.`,
-          { message_thread_id: tid, parse_mode: "Markdown", reply_parameters: { message_id: messageId } },
+          {
+            ...outboundThreadExtra(tid),
+            parse_mode: "Markdown",
+            reply_parameters: { message_id: messageId },
+          },
         )
         .catch(() => {});
       // Warm runtime; path-only message is not submitted as an agent prompt.
@@ -181,7 +188,10 @@ export async function resolveForumRuntime(
       .sendMessage(
         chatId,
         `\u2753 ${result.error}\n\n${BIND_HINT.replace(/\*\*/g, "")}`,
-        { message_thread_id: tid, reply_parameters: { message_id: messageId } },
+        {
+          ...outboundThreadExtra(tid),
+          reply_parameters: { message_id: messageId },
+        },
       )
       .catch(() => {});
     return "handled";
@@ -194,7 +204,7 @@ export async function resolveForumRuntime(
       .sendMessage(
         chatId,
         `\u2753 This topic is not linked to a project yet.\n${BIND_HINT.replace(/\*\*/g, "")}`,
-        { message_thread_id: tid },
+        outboundThreadExtra(tid),
       )
       .catch(() => {});
     return "handled";

package/src/bot/handlers/message.ts

@@ -8,22 +8,27 @@
  * rapid consecutive text messages per chat within a short debounce window
  * (`MESSAGE_BATCH_MS`) into a single prompt — one submission, one confirmation.
  *
- * User messages are replaced by a bot-owned prompt anchor (`#prompt_<id>`) so
- * the chat shows immediate life while CLI/ACP starts, and all AI replies thread
- * to that anchor with the same searchable tag.
+ * Project topics: user messages are replaced by a bot-owned prompt anchor
+ * (`#prompt_<id>`) so the chat shows immediate life while CLI/ACP starts.
  *
- * While a turn is running, the combined message is queued and runs
- * automatically when the current turn finishes.
- * (Wizard input and menu-button text are intercepted by earlier handlers.)
+ * General (manager): user messages are KEPT; AI replies thread to the user
+ * message. Each message is a NEW session (parallel), unless the user replies
+ * to a bot message — then that session continues.
  */
 import type { Bot } from "grammy";
 import { textPrompt } from "../../app/types.js";
 import { createLogger } from "../../logger.js";
-import { batchKey, forumThreadId } from "../../forum/thread.js";
+import {
+  batchKey,
+  forumThreadId,
+  isGeneralThread,
+  outboundThreadExtra,
+} from "../../forum/thread.js";
 import type { BotDeps } from "../deps.js";
-import { adoptUserPrompt } from "../prompt-anchor.js";
+import { adoptUserPrompt, newPromptId } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
 import { resolveForumRuntime } from "./forum.js";
+import type { SessionRuntime } from "../session-runtime.js";
 
 const log = createLogger("message");
 
@@ -35,6 +40,10 @@ interface TextBatch {
   threadId?: number;
   /** Reference content if the burst began as a reply to another message. */
   quoted?: string;
+  /** Telegram message_id the user is replying to (for session follow-up). */
+  replyToMessageId?: number;
+  /** Text of the replied-to message (for #sess_ recovery). */
+  replyToText?: string;
   timer: NodeJS.Timeout;
 }
 
@@ -49,7 +58,6 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
     const text = ctx.message.text;
     if (!text.trim()) return;
     // Slash commands are handled by bot.command / menu — never batch as agent prompts.
-    // (Otherwise /forum_setup and /help would also hit the debounce → agent path.)
     if (!text.includes("\n") && text.startsWith("/")) return;
 
     const chatId = ctx.chat.id;
@@ -58,7 +66,14 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
     const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
     const threadId = isForum ? forumThreadId(rawThreadId) : rawThreadId;
     const quoted = extractReplyContext(ctx);
-    const key = batchKey(chatId, rawThreadId, isForum);
+    const replyToMessageId = ctx.message.reply_to_message?.message_id;
+    const replyToText =
+      ctx.message.reply_to_message?.text ?? ctx.message.reply_to_message?.caption;
+    // General: do not coalesce independent messages (parallel sessions).
+    // Still coalesce multi-part 4096 splits when reply chain is empty and rapid.
+    const key = isGeneralThread(threadId) && isForum
+      ? `${chatId}:${threadId ?? 1}:m${id}`
+      : batchKey(chatId, rawThreadId, isForum);
 
     const batch = batches.get(key);
     if (batch) {
@@ -66,6 +81,10 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
       batch.parts.push(text);
       batch.ids.push(id);
       if (quoted && !batch.quoted) batch.quoted = quoted;
+      if (replyToMessageId !== undefined && batch.replyToMessageId === undefined) {
+        batch.replyToMessageId = replyToMessageId;
+        batch.replyToText = replyToText;
+      }
       batch.timer = arm(key);
       return;
     }
@@ -74,6 +93,8 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
       ids: [id],
       threadId,
       quoted,
+      replyToMessageId,
+      replyToText,
       timer: arm(key),
     });
   });
@@ -85,8 +106,6 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   if (!batch) return;
   batches.delete(key);
 
-  // Telegram splits at 4096 chars, almost always on a line boundary, so
-  // rejoining with a newline reconstructs the original text faithfully.
   const combined = batch.parts.join("\n").trim();
   if (!combined) return;
 
@@ -94,14 +113,16 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   const chatId = Number(chatIdStr);
   const threadId = batch.threadId;
 
-  // Defense-in-depth: never submit slash-only lines as agent prompts.
   if (batch.parts.length === 1 && !combined.includes("\n") && combined.startsWith("/")) {
     return;
   }
 
-  let rt = deps.registry.get(chatId);
-  // Forum group: topic-scoped multi-session controller (model/reasoning/running).
-  if (deps.forum?.isActiveForumChat(chatId)) {
+  const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+  const isGeneral = isForum && isGeneralThread(threadId);
+
+  let rt: SessionRuntime = deps.registry.get(chatId);
+
+  if (isForum && deps.forum) {
     const resolved = await resolveForumRuntime(
       deps,
       deps.forum,
@@ -111,10 +132,98 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
       batch.ids[0]!,
     );
     if (resolved === "handled" || resolved === "ignore") return;
+
+    if (isGeneral) {
+      // ── General manager path ─────────────────────────────────────────
+      const controller = deps.registry.forumController(
+        chatId,
+        forumThreadId(threadId),
+        resolved.rt.cwd,
+        resolved.rt.projectName ?? "General",
+      );
+
+      // Reply → continue same session (map, #sess_ on controlled runtimes, or disk).
+      // Fresh message → new parallel session (does not queue behind other General work).
+      const continueRt = await controller.resolveContinueFromReply({
+        replyToMessageId: batch.replyToMessageId,
+        replyToText: batch.replyToText,
+        cwd: resolved.rt.cwd,
+        projectName: resolved.rt.projectName ?? "General",
+      });
+
+      const userMsgId = batch.ids[0]!;
+      const replyTo = userMsgId;
+      // Keep user message; reply to it. No overwrite / adopt delete.
+
+      // New session: post "Starting…" FIRST (before ACP session/new) so the user
+      // sees life immediately. runTurn later edits it to Thinking… then streams.
+      // Follow-up on existing session: skip Starting (runTurn posts Thinking…).
+      let seedMessageId: number | undefined;
+      if (!continueRt) {
+        seedMessageId = await sendStatus(
+          deps,
+          chatId,
+          "Starting\u2026",
+          threadId,
+          replyTo,
+        );
+        rt = await controller.addParallel(
+          resolved.rt.cwd,
+          resolved.rt.projectName ?? "General",
+        );
+        if (seedMessageId !== undefined && rt.sessionId) {
+          controller.bindTelegramMessage(seedMessageId, rt.sessionId);
+        }
+      } else {
+        rt = continueRt;
+        // FG for status panel; manager setForeground keeps busy siblings streaming.
+        if (rt.sessionId) await controller.switchTo(rt.sessionId).catch(() => {});
+      }
+      if (rt.sessionId) controller.bindTelegramMessage(userMsgId, rt.sessionId);
+
+      try {
+        const outcome = await rt.submit(
+          textPrompt(combined, replyTo, batch.quoted, {
+            promptId: newPromptId(),
+            seedMessageId,
+          }),
+        );
+        if (rt.sessionId) {
+          controller.bindTelegramMessage(userMsgId, rt.sessionId);
+          if (seedMessageId !== undefined) {
+            controller.bindTelegramMessage(seedMessageId, rt.sessionId);
+          }
+        }
+        // Never show "queued" spam for new parallel sessions; only if continuing
+        // the same session that is already busy.
+        if (outcome === "queued" && continueRt) {
+          await send(
+            deps,
+            chatId,
+            `\u{1F4E5} Got it — queued as a follow-up on that thread.`,
+            threadId,
+            replyTo,
+          );
+        }
+      } catch (err) {
+        log.warn(`general submit failed chat ${chatId}: ${(err as Error).message}`);
+        if (seedMessageId !== undefined) {
+          await editStatus(deps, chatId, seedMessageId, `\u274C Couldn't start: ${(err as Error).message}`);
+        } else {
+          await send(
+            deps,
+            chatId,
+            `\u274C Couldn't start: ${(err as Error).message}`,
+            threadId,
+            replyTo,
+          );
+        }
+      }
+      return;
+    }
+
+    // ── Project / AI Chat topics (existing behavior) ─────────────────
     rt = resolved.rt;
-    // If nothing is selected / no session yet, ensure a new session is created
-    // on first message (ensureSession inside submit). If FG has no sessionId
-    // after a closed session, start a fresh one for this topic.
     if (!rt.sessionId && !rt.isBusy) {
       try {
         await rt.startNewSession(rt.cwd, rt.projectName);
@@ -125,11 +234,8 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   }
 
   const note = batch.parts.length > 1 ? ` (combined ${batch.parts.length} messages)` : "";
-  // Hoisted so a submit failure after a successful adopt can still thread the error.
   let replyTo: number | undefined = batch.ids[0];
   try {
-    // Instant bot anchor: user sees the prompt adopted immediately while CLI warms.
-    // All AI output + Done reply to this message and carry #prompt_<id>.
     const anchor = await adoptUserPrompt(deps.api, {
       chatId,
       text: combined,
@@ -151,7 +257,6 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
         replyTo,
       );
     }
-    // "ran": turn started; complexity is steered silently by the agent.
   } catch (err) {
     log.warn(`submit failed for chat ${chatId}: ${(err as Error).message}`);
     await send(
@@ -172,8 +277,7 @@ async function send(
   replyTo?: number,
 ): Promise<void> {
   try {
-    const extra: Record<string, unknown> = {};
-    if (threadId !== undefined) extra.message_thread_id = threadId;
+    const extra: Record<string, unknown> = { ...outboundThreadExtra(threadId) };
     if (replyTo !== undefined) {
       extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
     }
@@ -182,3 +286,39 @@ async function send(
     /* non-fatal */
   }
 }
+
+/** Post status bubble; returns message_id for later edit (Starting… → Thinking…). */
+async function sendStatus(
+  deps: BotDeps,
+  chatId: number,
+  text: string,
+  threadId?: number,
+  replyTo?: number,
+): Promise<number | undefined> {
+  try {
+    const extra: Record<string, unknown> = {
+      disable_notification: true,
+      ...outboundThreadExtra(threadId),
+    };
+    if (replyTo !== undefined) {
+      extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
+    }
+    const msg = await deps.api.sendMessage(chatId, text, extra);
+    return msg.message_id;
+  } catch {
+    return undefined;
+  }
+}
+
+async function editStatus(
+  deps: BotDeps,
+  chatId: number,
+  messageId: number,
+  text: string,
+): Promise<void> {
+  try {
+    await deps.api.editMessageText(chatId, messageId, text);
+  } catch {
+    /* non-fatal */
+  }
+}

package/src/bot/handlers/photo.ts

@@ -193,8 +193,11 @@ async function submit(
     quotedText: quoted,
   });
   if (outcome === "queued") {
+    // Omit General (1) — Bot API rejects message_thread_id=1.
     const extra: Record<string, unknown> =
-      threadId !== undefined ? { message_thread_id: threadId } : {};
+      threadId !== undefined && threadId !== 1
+        ? { message_thread_id: threadId }
+        : {};
     if (anchor?.replyTo !== undefined) {
       extra.reply_parameters = {
         message_id: anchor.replyTo,

package/src/bot/image-return.ts

@@ -145,7 +145,10 @@ export async function sendImages(
   if (opts.replyTo !== undefined) {
     extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
   }
-  if (opts.messageThreadId !== undefined) extra.message_thread_id = opts.messageThreadId;
+  // Omit General (1) — Bot API rejects message_thread_id=1.
+  if (opts.messageThreadId !== undefined && opts.messageThreadId !== 1) {
+    extra.message_thread_id = opts.messageThreadId;
+  }
   for (const path of paths) {
     if (sent >= opts.max) break;
     if (opts.already.has(path)) continue;