grok-telegram-bot 2.4.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

@@ -95,11 +95,24 @@ export class Ephemeral {
   async reply(ctx: Context, text: string, extra: Record<string, unknown> = {}): Promise<number | undefined> {
     const chatId = ctx.chat?.id;
     if (chatId === undefined) return undefined;
+    // Stay in the forum topic when the trigger message was in a thread.
+    const msg = ctx.message ?? ctx.callbackQuery?.message;
+    const threadId =
+      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 &&
+      threadId !== 1 &&
+      extra.message_thread_id === undefined
+        ? { ...extra, message_thread_id: threadId }
+        : extra;
     return this.serialize(chatId, async () => {
       try {
-        const msg = await ctx.reply(text, extra);
-        this.remember(chatId, msg.message_id);
-        return msg.message_id;
+        const m = await ctx.reply(text, merged);
+        this.remember(chatId, m.message_id);
+        return m.message_id;
       } catch {
         return undefined;
       }

package/src/bot/menu/keyboard.ts

@@ -1,32 +1,71 @@
 /**
  * Menu surfaces:
- *  - a tiny PERSISTENT bar (☰ Menu · 🧭 Running · ⏹ Stop) — minimal footprint;
- *  - a full, organized INLINE menu opened on demand (and hideable).
- * Live state (project/model/reasoning/context) lives in the pinned panel,
- * so the bar stays clean. (Agent picker removed — Grok has no useful headless
- * agent switch; plan mode is entered automatically when the agent judges the task complex.)
+ *  - PERSISTENT bar (reply keyboard): ☰ Menu · 🆕 New session / 🧭 Running · ⏹ Stop
+ *    — primary place for New session in private chats (not the inline Menu message).
+ *  - INLINE menu message (opened via ☰ Menu or /menu) — settings & navigation.
+ *    Forum topics: reply keyboards are unreliable, so New stays on the topic inline menu.
+ * Live state lives in the pinned status panel so the bar stays clean.
  */
 import { InlineKeyboard, Keyboard } from "grammy";
 
 export const MENU_BTN = "\u2630 Menu"; // ☰
+/** Persistent bar + forum topic control — brand-new session (same as /new). */
+export const NEW_BTN = "\u{1F195} New session";
 export const RUNNING_BTN = "\u{1F9ED} Running";
 export const STOP_BTN = "\u23F9 Stop";
-export const BAR_LABELS = [MENU_BTN, RUNNING_BTN, STOP_BTN];
+export const BAR_LABELS = [MENU_BTN, NEW_BTN, RUNNING_BTN, STOP_BTN];
 
-/** The always-visible compact bar. */
+/** The always-visible compact bar (private chats; best-effort in groups). */
 export function compactKeyboard(): Keyboard {
-  return new Keyboard().text(MENU_BTN).text(RUNNING_BTN).text(STOP_BTN).resized().persistent();
+  return new Keyboard()
+    .text(MENU_BTN)
+    .text(NEW_BTN)
+    .row()
+    .text(RUNNING_BTN)
+    .text(STOP_BTN)
+    .resized()
+    .persistent();
 }
 
 /** The full, grouped inline menu (opened via ☰ Menu or /menu). */
-export function mainMenuInline(state: { model: string; reasoning: string }): InlineKeyboard {
+export function mainMenuInline(state: {
+  model: string;
+  reasoning: string;
+  /** Forum topic scope — hide project switch; label topic sessions. */
+  forumTopic?: { name: string; account?: string };
+}): InlineKeyboard {
   const t = (s: string, n: number): string => (s.length > n ? s.slice(0, n - 1) + "\u2026" : s);
-  return new InlineKeyboard()
-    .text("\u{1F4C1} Project", "m:project")
-    .text("\u{1F195} New", "m:new")
+  const kb = new InlineKeyboard();
+
+  if (state.forumTopic) {
+    // Groups/topics: control first (no reliable reply-keyboard bar). New session here.
+    kb.text("\u23F9 Stop", "m:stop")
+      .text("\u{1F9ED} Running", "m:running")
+      .row()
+      .text(NEW_BTN, "m:new")
+      .text("\u{1F5C2} Sessions", "m:sessions")
+      .row()
+      .text(`\u{1F4C1} ${t(state.forumTopic.name, 28)}`, "m:topicinfo")
+      .row()
+      .text("\u{1F4E5} Import session", "m:import")
+      .row()
+      .text(`\u{1F9E9} Model \u00B7 ${t(state.model, 24)}`, "m:model")
+      .row()
+      .text(`\u{1F9E0} Reasoning \u00B7 ${t(state.reasoning, 24)}`, "m:reasoning")
+      .row();
+    if (state.forumTopic.account) {
+      kb.text(`\u{1F465} Account \u00B7 ${t(state.forumTopic.account, 20)}`, "m:accounts").row();
+    }
+    kb.text("\u{1F4CA} Status", "m:status").text("\u2716 Close", "m:close");
+    return kb;
+  }
+
+  // Private chat: New session is on the persistent bar + /new — not on this message.
+  kb.text("\u{1F4C1} Project", "m:project")
+    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
+    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F9ED} Running", "m:running")
-    .text("\u{1F5C2} Sessions", "m:sessions")
     .row()
     .text("\u{1F4E5} Import session", "m:import")
     .row()
@@ -41,10 +80,10 @@ export function mainMenuInline(state: { model: string; reasoning: string }): Inl
     .text("\u{1F465} Accounts", "m:accounts")
     .row()
     .text("\u{1F9E9} MCP", "m:mcp")
-    .text("\u23F9 Stop", "m:stop")
     .text("\u{1F6D1} Kill all", "m:killall")
     .row()
     .text("\u2328\uFE0F Show bar", "m:showbar")
     .text("\u{1F648} Hide bar", "m:hidebar")
     .text("\u2716 Close", "m:close");
+  return kb;
 }

package/src/bot/menu/refresh.ts

@@ -4,10 +4,12 @@
  */
 import type { Context } from "grammy";
 import type { BotDeps } from "../deps.js";
+import { resolveScope } from "../scope.js";
 import { compactKeyboard } from "./keyboard.js";
 
 export async function refreshMenu(ctx: Context, deps: BotDeps, text: string): Promise<void> {
   const chatId = ctx.chat!.id;
-  await ctx.reply(text, { reply_markup: compactKeyboard() });
+  const scope = resolveScope(ctx, deps);
+  await ctx.reply(text, { reply_markup: compactKeyboard(), ...scope.threadExtra });
   await deps.statusPanel.refresh(chatId);
 }

package/src/bot/menu/status-panel.ts

@@ -65,13 +65,19 @@ export class StatusPanel {
     if (subagents) activity.push(`\u{1F465} ${subagents}`);
     lines.push(activity.join(SEP));
 
-    // 3b) What is happening now / last summary (same source as Running cards).
-    // Prefer plan one-liner over a redundant tool-step when a plan is active.
-    const comment = rt.planSummary && rt.isBusy ? undefined : rt.cardComment;
+    // 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 icon = rt.isBusy ? "\u23F3" : "\u{1F4AC}";
-      const shown = comment.length > 120 ? `${comment.slice(0, 119)}\u2026` : comment;
-      lines.push(`${icon} ${shown}`);
+      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.

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) {