grok-telegram-bot 2.5.0 → 2.6.0

package/src/bot/manager-context.ts

@@ -0,0 +1,208 @@
+/**
+ * Auto-injected context for General manager turns: topic catalog, memory hits,
+ * recent General chat history, and active dispatch jobs.
+ */
+import { join } from "node:path";
+import type { ForumManager } from "../forum/manager.js";
+import { readHistory } from "../sessions/history.js";
+import type { SessionStore } from "../sessions/store.js";
+import { searchGroupMemory } from "./group-memory.js";
+import { listActiveManagerJobs, listRecentManagerJobs, type ManagerJob } from "./manager-jobs.js";
+
+export const MANAGER_CONTEXT_MARKER = "MANAGER CONTEXT (auto — use before dispatching work):";
+
+const CONTEXT_MAX = 6500;
+
+export interface ManagerContextOpts {
+  userText: string;
+  sessionsDir: string;
+  store: SessionStore;
+  forum?: ForumManager;
+  /** Override jobs list (tests). */
+  jobs?: ManagerJob[];
+}
+
+/** Build a capped context block for manager prompts. */
+export function buildManagerContextBlock(opts: ManagerContextOpts): string {
+  const lines: string[] = [MANAGER_CONTEXT_MARKER, ""];
+
+  const topics = opts.forum?.isReady ? opts.forum.store.all() : [];
+  lines.push("## Topics");
+  if (topics.length === 0) {
+    lines.push("(no forum topics mapped)");
+  } else {
+    const topicCap = 40;
+    for (const t of topics.slice(0, topicCap)) {
+      const path = t.projectPath ?? "(unbound)";
+      lines.push(`- **${t.name}** #${t.threadId} [${t.kind}] \`${path}\``);
+    }
+    if (topics.length > topicCap) {
+      lines.push(`… +${topics.length - topicCap} more (use list_topics)`);
+    }
+  }
+
+  const workspace =
+    topics.find((t) => t.kind === "general")?.projectPath ||
+    topics.find((t) => t.kind === "ai_chat")?.projectPath ||
+    undefined;
+  const preferPaths = [
+    workspace,
+    ...topics
+      .filter((t) => t.kind === "project" && t.projectPath)
+      .map((t) => t.projectPath!)
+      .slice(0, 12),
+  ].filter(Boolean) as string[];
+
+  // Always surface recent General chat so the manager "remembers" this room.
+  lines.push("", "## Recent General chat (always available)");
+  const generalSnips = recentGeneralHistory(opts, workspace, 10);
+  if (generalSnips.length === 0) {
+    lines.push("(no prior General history on disk yet)");
+  } else {
+    for (const s of generalSnips) lines.push(`- ${s}`);
+  }
+
+  lines.push(
+    "",
+    "## Memory hits (ranked: relevance + recency — newest work first, not git)",
+  );
+  const hits = searchGroupMemory({
+    query: opts.userText,
+    limit: 14,
+    sessionsDir: opts.sessionsDir,
+    store: opts.store,
+    topics: topics.length ? topics : undefined,
+    preferPaths,
+    preferGeneral: true,
+    maxSessions: 32,
+  });
+  if (hits.length === 0) {
+    lines.push(
+      "(no hits — call search_memory; do NOT run git until memory is exhausted)",
+    );
+  } else {
+    for (const h of hits) {
+      const where =
+        h.threadId !== undefined
+          ? ` #${h.threadId}`
+          : h.sessionId
+            ? ` session=${h.sessionId.slice(0, 8)}`
+            : "";
+      lines.push(`- [${h.kind}] ${h.title}${where}: ${h.snippet}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "Rules: for \"last modifications / last work\" trust hits with [Xm/h/d ago] stamps — prefer the newest session for that project path.",
+    "Ignore older OmniRoute-style notes if a newer session for the same path exists.",
+    "Do not use git log/status as the first step unless the user asked for git.",
+  );
+
+  const jobs = opts.jobs ?? [...listActiveManagerJobs(8), ...listRecentManagerJobs(4)];
+  const seen = new Set<string>();
+  const uniq: ManagerJob[] = [];
+  for (const j of jobs) {
+    if (seen.has(j.id)) continue;
+    seen.add(j.id);
+    uniq.push(j);
+    if (uniq.length >= 10) break;
+  }
+  lines.push("", "## Manager jobs (this process)");
+  if (uniq.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const j of uniq) {
+      const ageMin = Math.max(0, Math.round((Date.now() - j.createdAt) / 60_000));
+      lines.push(
+        `- ${j.status} **${j.targetName}** #${j.targetThreadId} (${ageMin}m ago) job=${j.id}` +
+          (j.childSessionId ? ` session=${j.childSessionId.slice(0, 8)}` : ""),
+      );
+      if (j.userAskPreview) lines.push(`  ask: ${clamp(j.userAskPreview, 160)}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "Use this context to pick the right topic and write a strong send_prompt.",
+    "When a hit shows session=XXXXXXXX and the user wants follow-up there, pass that exact",
+    "prefix as session_id on send_prompt (do NOT rely on the topic's currently open session).",
+    "Prefer search_memory again if you need deeper history before dispatching.",
+  );
+
+  let block = lines.join("\n");
+  if (block.length > CONTEXT_MAX) {
+    block = block.slice(0, CONTEXT_MAX - 1) + "\u2026";
+  }
+  return block;
+}
+
+/** Last user/assistant lines from General-named or workspace sessions. */
+function recentGeneralHistory(
+  opts: ManagerContextOpts,
+  workspace: string | undefined,
+  limit: number,
+): string[] {
+  const out: string[] = [];
+  let metas;
+  try {
+    metas = opts.store.list(40);
+  } catch {
+    return out;
+  }
+  const ws = workspace?.replace(/\\/g, "/").toLowerCase();
+  const ranked = metas
+    .map((m) => {
+      const title = (m.title || "").toLowerCase();
+      const cwd = (m.cwd || "").replace(/\\/g, "/").toLowerCase();
+      let rank = 0;
+      // Prefer sessions explicitly labeled General — never treat every project
+      // under the workspace root as "General chat" (path prefix trap).
+      if (title === "general") rank += 12;
+      else if (/\bgeneral\b/.test(title)) rank += 6;
+      // Exact workspace cwd only (General/AI Chat bind), not child project paths.
+      if (ws && cwd === ws) rank += 4;
+      return { m, rank };
+    })
+    .filter((x) => x.rank > 0)
+    .sort(
+      (a, b) =>
+        b.rank - a.rank ||
+        String(b.m.updatedAt || "").localeCompare(String(a.m.updatedAt || "")),
+    );
+
+  for (const { m } of ranked.slice(0, 4)) {
+    try {
+      const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
+      const entries = readHistory(path, 8);
+      for (const e of entries) {
+        if (!e.text?.trim()) continue;
+        // Skip huge manager context dumps in history.
+        if (e.text.includes(MANAGER_CONTEXT_MARKER)) continue;
+        if (e.text.startsWith("MANAGER MODE")) continue;
+        const role = e.role === "user" ? "user" : e.role === "assistant" ? "bot" : e.role;
+        out.push(
+          `${role} · ${m.sessionId.slice(0, 8)}: ${clamp(e.text.replace(/\s+/g, " "), 180)}`,
+        );
+        if (out.length >= limit) return out;
+      }
+    } catch {
+      /* skip */
+    }
+  }
+  return out;
+}
+
+/** Prepend context block to a user/manager prompt body (idempotent). */
+export function injectManagerContext(text: string, contextBlock: string): string {
+  const body = text.trim();
+  if (!contextBlock.trim()) return body;
+  if (body.includes(MANAGER_CONTEXT_MARKER)) return body;
+  return `${contextBlock}\n\n---\n\n${body}`;
+}
+
+function clamp(s: string, max: number): string {
+  const t = s.replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  return t.slice(0, max - 1) + "\u2026";
+}

package/src/bot/manager-jobs.ts

@@ -0,0 +1,142 @@
+/**
+ * In-memory tracking of work dispatched from General (manager) into project topics.
+ * Used for status, context inject, and report-back when a child turn finishes.
+ */
+
+export type ManagerJobStatus = "dispatched" | "running" | "done" | "failed" | "cancelled";
+
+export interface ManagerJob {
+  id: string;
+  originChatId: number;
+  originThreadId: number;
+  targetThreadId: number;
+  targetName: string;
+  targetPath: string;
+  childSessionId?: string;
+  dispatchPrompt: string;
+  userAskPreview: string;
+  createdAt: number;
+  updatedAt: number;
+  status: ManagerJobStatus;
+  resultSummary?: string;
+}
+
+export interface ReportBackMeta {
+  jobId: string;
+  originChatId: number;
+  originThreadId: number;
+  userAskPreview: string;
+  targetName: string;
+  targetPath: string;
+  dispatchPrompt: string;
+}
+
+const MAX_JOBS = 100;
+
+const jobsById = new Map<string, ManagerJob>();
+const jobIdBySession = new Map<string, string>();
+
+let seq = 0;
+
+export function newManagerJobId(): string {
+  seq = (seq + 1) % 1_000_000;
+  return `mj_${Date.now().toString(36)}_${seq.toString(36)}`;
+}
+
+export function registerManagerJob(input: {
+  originChatId: number;
+  originThreadId: number;
+  targetThreadId: number;
+  targetName: string;
+  targetPath: string;
+  dispatchPrompt: string;
+  userAskPreview: string;
+  childSessionId?: string;
+}): ManagerJob {
+  const now = Date.now();
+  const job: ManagerJob = {
+    id: newManagerJobId(),
+    originChatId: input.originChatId,
+    originThreadId: input.originThreadId,
+    targetThreadId: input.targetThreadId,
+    targetName: input.targetName,
+    targetPath: input.targetPath,
+    childSessionId: input.childSessionId,
+    dispatchPrompt: input.dispatchPrompt,
+    userAskPreview: input.userAskPreview,
+    createdAt: now,
+    updatedAt: now,
+    status: "dispatched",
+  };
+  jobsById.set(job.id, job);
+  if (job.childSessionId) jobIdBySession.set(job.childSessionId, job.id);
+  trimJobs();
+  return job;
+}
+
+export function bindJobSession(jobId: string, sessionId: string): void {
+  const job = jobsById.get(jobId);
+  if (!job) return;
+  job.childSessionId = sessionId;
+  job.updatedAt = Date.now();
+  if (job.status === "dispatched") job.status = "running";
+  jobIdBySession.set(sessionId, jobId);
+}
+
+export function updateManagerJob(
+  jobId: string,
+  patch: Partial<Pick<ManagerJob, "status" | "resultSummary" | "childSessionId">>,
+): ManagerJob | undefined {
+  const job = jobsById.get(jobId);
+  if (!job) return undefined;
+  if (patch.status !== undefined) job.status = patch.status;
+  if (patch.resultSummary !== undefined) job.resultSummary = patch.resultSummary;
+  if (patch.childSessionId !== undefined) {
+    job.childSessionId = patch.childSessionId;
+    jobIdBySession.set(patch.childSessionId, jobId);
+  }
+  job.updatedAt = Date.now();
+  return job;
+}
+
+export function getManagerJob(jobId: string): ManagerJob | undefined {
+  return jobsById.get(jobId);
+}
+
+export function getJobBySession(sessionId: string): ManagerJob | undefined {
+  const id = jobIdBySession.get(sessionId);
+  return id ? jobsById.get(id) : undefined;
+}
+
+/** Active (not terminal) jobs, newest first. */
+export function listActiveManagerJobs(limit = 12): ManagerJob[] {
+  return [...jobsById.values()]
+    .filter((j) => j.status === "dispatched" || j.status === "running")
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, limit);
+}
+
+/** Recent jobs including finished, newest first. */
+export function listRecentManagerJobs(limit = 12): ManagerJob[] {
+  return [...jobsById.values()]
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, Math.max(1, Math.min(50, limit)));
+}
+
+function trimJobs(): void {
+  if (jobsById.size <= MAX_JOBS) return;
+  const ordered = [...jobsById.values()].sort((a, b) => a.updatedAt - b.updatedAt);
+  const drop = ordered.length - MAX_JOBS;
+  for (let i = 0; i < drop; i++) {
+    const j = ordered[i]!;
+    jobsById.delete(j.id);
+    if (j.childSessionId) jobIdBySession.delete(j.childSessionId);
+  }
+}
+
+/** Test helper: wipe job state. */
+export function clearManagerJobsForTests(): void {
+  jobsById.clear();
+  jobIdBySession.clear();
+  seq = 0;
+}

package/src/bot/menu/ephemeral.ts

@@ -101,8 +101,11 @@ export class Ephemeral {
       msg && "message_thread_id" in msg
         ? (msg as { message_thread_id?: number }).message_thread_id
         : undefined;
+    // Omit General (1) — Bot API rejects message_thread_id=1.
     const merged =
-      threadId !== undefined && extra.message_thread_id === undefined
+      threadId !== undefined &&
+      threadId !== 1 &&
+      extra.message_thread_id === undefined
         ? { ...extra, message_thread_id: threadId }
         : extra;
     return this.serialize(chatId, async () => {

package/src/bot/prompt-anchor.ts

@@ -15,6 +15,7 @@ import type { Api, Context } from "grammy";
 import { InputMediaBuilder } from "grammy";
 import { createLogger } from "../logger.js";
 import { tagSafe } from "../render/hashtags.js";
+import { outboundThreadExtra } from "../forum/thread.js";
 
 const log = createLogger("prompt-anchor");
 
@@ -123,10 +124,8 @@ export async function adoptUserPrompt(
   });
   const threadExtra: Record<string, unknown> = {
     disable_notification: true,
+    ...outboundThreadExtra(opts.messageThreadId),
   };
-  if (opts.messageThreadId !== undefined) {
-    threadExtra.message_thread_id = opts.messageThreadId;
-  }
 
   let replyTo: number;
   try {

package/src/bot/prompt-content.ts

@@ -69,6 +69,9 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
   // 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);
+  // First reportBack wins (oldest queued manager dispatch in this merge batch).
+  const reportBack = inputs.find((i) => i.reportBack)?.reportBack;
+  const seedMessageId = inputs.find((i) => i.seedMessageId !== undefined)?.seedMessageId;
   return {
     text: inputs
       .map((i) => i.text)
@@ -82,6 +85,8 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
     promptId: inputs.find((i) => i.promptId)?.promptId,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
     skipSelfRecheck: skipSelfRecheck || undefined,
+    reportBack,
+    seedMessageId,
   };
 }
 

package/src/bot/scope.ts

@@ -6,8 +6,11 @@ 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";
+import {
+  forumThreadId,
+  FORUM_GENERAL_THREAD_ID,
+  outboundThreadExtra,
+} from "../forum/thread.js";
 
 export interface HandlerScope {
   chatId: number;
@@ -48,10 +51,6 @@ 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);
@@ -61,7 +60,8 @@ export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
       settingsKey: settingsKeyFor(chatId),
       controller,
       rt: controller.foreground(),
-      threadExtra: rawThread !== undefined ? { message_thread_id: rawThread } : {},
+      // Private chats rarely have threads; still omit General-style id 1.
+      threadExtra: outboundThreadExtra(rawThread),
     };
   }
 
@@ -87,7 +87,8 @@ export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
     settingsKey: settingsKeyFor(chatId, tid),
     controller,
     rt: controller.foreground(),
-    threadExtra: { message_thread_id: tid },
+    // Outbound: never pass message_thread_id=1 (General) — Telegram rejects it.
+    threadExtra: outboundThreadExtra(tid),
     projectPath: cwd,
     projectName,
   };