grok-telegram-bot 2.5.0 → 2.7.0

package/src/bot/telegram-actions.ts

@@ -6,10 +6,21 @@ import type { Api } from "grammy";
 import type { AppConfig } from "../config.js";
 import type { ForumManager } from "../forum/manager.js";
 import type { ForumTopicBinding } from "../forum/types.js";
-import { FORUM_GENERAL_THREAD_ID } from "../forum/thread.js";
+import {
+  FORUM_GENERAL_THREAD_ID,
+  isGeneralThread,
+  outboundThreadExtra,
+} from "../forum/thread.js";
 import type { SessionStore } from "../sessions/store.js";
 import { createLogger } from "../logger.js";
 import { searchGroupMemory } from "./group-memory.js";
+import {
+  bindJobSession,
+  listRecentManagerJobs,
+  registerManagerJob,
+  updateManagerJob,
+  type ReportBackMeta,
+} from "./manager-jobs.js";
 import type { TelegramBotService } from "./telegram-bots.js";
 import type { TelegramAction } from "../render/telegram-bridge.js";
 
@@ -22,6 +33,13 @@ export type SubmitTopicPromptFn = (opts: {
   projectName: string;
   prompt: string;
   newSession?: boolean;
+  /**
+   * Resume this exact Grok session in the target topic (full UUID or short
+   * prefix from memory hits). When set, overrides newSession / foreground.
+   */
+  sessionId?: string;
+  /** When set, child session reports completion back to General. */
+  reportBack?: ReportBackMeta;
 }) => Promise<{ outcome: "ran" | "queued"; sessionId?: string }>;
 
 export interface TelegramActionContext {
@@ -29,11 +47,20 @@ export interface TelegramActionContext {
   cfg: AppConfig;
   chatId: number;
   messageThreadId?: number;
+  /** Reply-to for notify (usually the user's message that started the turn). */
+  replyToMessageId?: number;
   forum?: ForumManager;
   store: SessionStore;
   bots: TelegramBotService;
   /** Dispatch a prompt into another forum topic's session. */
   submitTopicPrompt?: SubmitTopicPromptFn;
+  /**
+   * When actions originate from General manager, register jobs + report-back
+   * and suppress chat spam notes for durable actions.
+   */
+  managerMode?: boolean;
+  /** Short preview of the user ask that triggered this manager turn. */
+  managerUserAskPreview?: string;
 }
 
 export interface TelegramActionResult {
@@ -75,8 +102,14 @@ async function runOne(
       return setPath(action, ctx);
     case "send_prompt":
       return sendPrompt(action, ctx);
+    case "notify":
+      return notifyUser(action, ctx);
     case "search_memory":
       return searchMemory(action, ctx);
+    case "list_topics":
+      return listTopics(ctx);
+    case "list_jobs":
+      return listJobs();
     case "list_bots":
       return listBots(ctx);
     case "bot_command":
@@ -113,9 +146,11 @@ async function createTopic(
       projectPath: b.projectPath,
       kind: b.kind,
     },
-    userNote: b.projectPath
-      ? `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\``
-      : `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) (unbound — use set_path)`,
+    userNote: ctx.managerMode
+      ? undefined
+      : b.projectPath
+        ? `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\``
+        : `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) (unbound — use set_path)`,
   };
 }
 
@@ -168,10 +203,57 @@ function setPath(
       kind: b.kind,
       created: !!result.created,
     },
-    userNote: `\u{1F4C1} Topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\`${createdNote}`,
+    userNote: ctx.managerMode
+      ? undefined
+      : `\u{1F4C1} Topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\`${createdNote}`,
   };
 }
 
+/**
+ * Explicit user-facing message. In General this is the only chat surface —
+ * free-form agent prose is not streamed.
+ */
+async function notifyUser(
+  action: Extract<TelegramAction, { action: "notify" }>,
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult> {
+  const text = action.text.trim();
+  if (!text) {
+    return { action: "notify", ok: false, error: "Empty notify text" };
+  }
+  try {
+    const extra: Record<string, unknown> = {
+      disable_notification: !action.important,
+      // General: never pass message_thread_id=1 (Telegram rejects it).
+      ...outboundThreadExtra(ctx.messageThreadId),
+    };
+    if (ctx.replyToMessageId !== undefined) {
+      extra.reply_parameters = {
+        message_id: ctx.replyToMessageId,
+        allow_sending_without_reply: true,
+      };
+    }
+    const msg = await ctx.api.sendMessage(ctx.chatId, text, extra);
+    return {
+      action: "notify",
+      ok: true,
+      data: {
+        messageId: msg.message_id,
+        chars: text.length,
+        important: !!action.important,
+      },
+      // Never double-post via userNote — the message already went out.
+      userNote: undefined,
+    };
+  } catch (e) {
+    return {
+      action: "notify",
+      ok: false,
+      error: (e as Error).message ?? String(e),
+    };
+  }
+}
+
 async function sendPrompt(
   action: Extract<TelegramAction, { action: "send_prompt" }>,
   ctx: TelegramActionContext,
@@ -192,12 +274,102 @@ async function sendPrompt(
     };
   }
 
-  const resolved = resolveTopicRef(forum, action.topic, ctx.cfg);
-  if (!resolved.ok) {
-    return { action: "send_prompt", ok: false, error: resolved.error };
+  // Resolve session_id first when present. A real session can recover a missing
+  // or placeholder topic (e.g. topic: "…") by matching session.cwd → forum binding.
+  let resumeSessionId: string | undefined;
+  let resumeCwd: string | undefined;
+  let inferredFromMemory = false;
+  if (action.sessionId) {
+    const resolvedSess = resolveSessionRef(ctx.store, action.sessionId);
+    if (!resolvedSess.ok) {
+      return {
+        action: "send_prompt",
+        ok: false,
+        error: resolvedSess.error,
+        data: { topic: action.topic, sessionRef: action.sessionId },
+      };
+    }
+    resumeSessionId = resolvedSess.sessionId;
+    if (resolvedSess.cwd) resumeCwd = resolvedSess.cwd;
   }
-  const { binding } = resolved;
-  const cwd = binding.projectPath;
+
+  let binding: ForumTopicBinding | undefined;
+  let topicError: string | undefined;
+  const topicRef = (action.topic || "").trim();
+  const topicIsPlaceholder = isPlaceholderTopicRef(topicRef);
+
+  if (topicRef && !topicIsPlaceholder) {
+    const resolved = resolveTopicRef(forum, topicRef, ctx.cfg);
+    if (resolved.ok) {
+      binding = resolved.binding;
+    } else {
+      topicError = resolved.error;
+    }
+  }
+
+  // Fallback: map session cwd → topic when topic missing, placeholder, or not found.
+  if (!binding && resumeCwd) {
+    const fromPath = resolveTopicFromPath(forum, resumeCwd);
+    if (fromPath) binding = fromPath;
+  }
+
+  // Last resort: model used topic "…" / wrong name without session_id — infer from
+  // memory using the user ask + prompt text, then map path → forum topic.
+  if (!binding) {
+    const inferred = inferDispatchTarget(ctx, forum, [
+      ctx.managerUserAskPreview || "",
+      action.prompt.slice(0, 400),
+      topicIsPlaceholder ? "" : topicRef,
+    ]);
+    if (inferred) {
+      binding = inferred.binding;
+      if (!resumeSessionId && inferred.sessionId) {
+        resumeSessionId = inferred.sessionId;
+        resumeCwd = inferred.cwd || inferred.binding.projectPath || resumeCwd;
+        inferredFromMemory = true;
+      } else if (!resumeCwd && inferred.cwd) {
+        resumeCwd = inferred.cwd;
+        inferredFromMemory = true;
+      } else {
+        inferredFromMemory = true;
+      }
+    }
+  }
+
+  if (!binding) {
+    const hint = listTopicHints(forum);
+    const topics = safeListTopics(forum);
+    if (topicIsPlaceholder || !topicRef) {
+      return {
+        action: "send_prompt",
+        ok: false,
+        error:
+          (topicIsPlaceholder
+            ? `Topic is a placeholder ("${topicRef || "…"}"). Pass exact title, #threadId, or session_id (memory could not auto-infer a project topic).`
+            : "Topic missing. Pass exact title, #threadId, or session_id.") +
+          (hint ? ` Available: ${hint}` : " Call list_topics first."),
+        data: {
+          topic: action.topic,
+          sessionRef: action.sessionId,
+          resumeSessionId,
+          availableTopics: topics,
+        },
+      };
+    }
+    return {
+      action: "send_prompt",
+      ok: false,
+      error: (topicError || `Topic not found: "${topicRef}".`) + (hint ? ` Available: ${hint}` : ""),
+      data: {
+        topic: action.topic,
+        sessionRef: action.sessionId,
+        resumeSessionId,
+        availableTopics: topics,
+      },
+    };
+  }
+
+  const cwd = binding.projectPath || resumeCwd;
   if (!cwd) {
     return {
       action: "send_prompt",
@@ -205,6 +377,16 @@ async function sendPrompt(
       error: `Topic **${binding.name}** (#${binding.threadId}) has no project path — use set_path or create_topic with path first`,
     };
   }
+  if (!resumeCwd) resumeCwd = cwd;
+
+  // If session was resolved without path filter, re-prefer under this topic when ambiguous.
+  if (action.sessionId && resumeSessionId) {
+    const refined = resolveSessionRef(ctx.store, action.sessionId, cwd);
+    if (refined.ok) {
+      resumeSessionId = refined.sessionId;
+      if (refined.cwd) resumeCwd = refined.cwd;
+    }
+  }
 
   const projectName =
     binding.kind === "ai_chat"
@@ -213,28 +395,57 @@ async function sendPrompt(
         ? "General"
         : binding.name;
 
-  // Visible injection in the *target* topic so humans see the orchestrated prompt.
-  // Plain text (no Markdown) so agent prompts with * _ ` cannot break the send.
-  const preview =
-    action.prompt.length > 1500 ? action.prompt.slice(0, 1499) + "\u2026" : action.prompt;
-  await ctx.api
-    .sendMessage(
-      forum.groupId,
-      `\u{1F4E8} Prompt from bridge${action.newSession ? " (new session)" : ""}\n\n${preview}`,
-      { message_thread_id: binding.threadId },
-    )
-    .catch((e) => {
-      log.debug(`send_prompt announce failed: ${(e as Error).message}`);
-    });
+  // Human-visible announce in the *target* topic (may be multi-message).
+  // The full `action.prompt` is always submitted to the agent below — never crop it here.
+  const sessNote = resumeSessionId ? ` → session ${resumeSessionId.slice(0, 8)}` : "";
+  await announceBridgePrompt(
+    ctx.api,
+    forum.groupId,
+    binding.threadId,
+    action.prompt,
+    !!action.newSession && !resumeSessionId,
+    sessNote,
+  );
+
+  // Manager → project: register job and ask the child runtime to report back.
+  let reportBack: ReportBackMeta | undefined;
+  if (ctx.managerMode && isGeneralThread(ctx.messageThreadId)) {
+    // Never report-back into the same general loop for self-prompts.
+    if (binding.threadId !== FORUM_GENERAL_THREAD_ID) {
+      const job = registerManagerJob({
+        originChatId: ctx.chatId,
+        originThreadId: FORUM_GENERAL_THREAD_ID,
+        targetThreadId: binding.threadId,
+        targetName: binding.name,
+        targetPath: resumeCwd,
+        dispatchPrompt: action.prompt,
+        userAskPreview: (ctx.managerUserAskPreview || action.prompt).slice(0, 400),
+      });
+      reportBack = {
+        jobId: job.id,
+        originChatId: job.originChatId,
+        originThreadId: job.originThreadId,
+        userAskPreview: job.userAskPreview,
+        targetName: job.targetName,
+        targetPath: job.targetPath,
+        dispatchPrompt: job.dispatchPrompt,
+      };
+    }
+  }
 
   try {
     const res = await ctx.submitTopicPrompt({
       threadId: binding.threadId,
-      cwd,
+      cwd: resumeCwd,
       projectName,
       prompt: action.prompt,
-      newSession: action.newSession,
+      newSession: !!action.newSession && !resumeSessionId,
+      sessionId: resumeSessionId,
+      reportBack,
     });
+    if (reportBack && res.sessionId) {
+      bindJobSession(reportBack.jobId, res.sessionId);
+    }
     return {
       action: "send_prompt",
       ok: true,
@@ -244,23 +455,320 @@ async function sendPrompt(
         projectPath: cwd,
         outcome: res.outcome,
         sessionId: res.sessionId,
-        newSession: !!action.newSession,
+        resumedSessionId: resumeSessionId,
+        inferredFromMemory: inferredFromMemory || undefined,
+        newSession: !!action.newSession && !resumeSessionId,
         promptPreview: action.prompt.slice(0, 200),
+        jobId: reportBack?.jobId,
+        reportBack: !!reportBack,
       },
-      userNote: `\u{1F4E8} Prompt ${res.outcome} in **${binding.name}** (#${binding.threadId})`,
+      // Manager mode: keep General quiet — agent prose confirms dispatch.
+      userNote: ctx.managerMode
+        ? undefined
+        : `\u{1F4E8} Prompt ${res.outcome} in **${binding.name}** (#${binding.threadId})` +
+          (resumeSessionId ? ` session ${resumeSessionId.slice(0, 8)}` : ""),
     };
   } catch (e) {
+    if (reportBack) {
+      updateManagerJob(reportBack.jobId, {
+        status: "failed",
+        resultSummary: `dispatch failed: ${(e as Error).message ?? String(e)}`.slice(0, 400),
+      });
+    }
     return {
       action: "send_prompt",
       ok: false,
       error: (e as Error).message ?? String(e),
-      data: { threadId: binding.threadId, name: binding.name, projectPath: cwd },
+      data: {
+        threadId: binding.threadId,
+        name: binding.name,
+        projectPath: cwd,
+        jobId: reportBack?.jobId,
+        sessionRef: action.sessionId,
+      },
+    };
+  }
+}
+
+/**
+ * Resolve a session ref from memory (full UUID or short prefix like 019fc9ec)
+ * to a concrete on-disk session. Prefer sessions under topicCwd when multiple match.
+ */
+export function resolveSessionRef(
+  store: SessionStore,
+  ref: string,
+  topicCwd?: string,
+): { ok: true; sessionId: string; cwd?: string } | { ok: false; error: string } {
+  const raw = ref.trim().replace(/^#?sess[_-]?/i, "");
+  if (!raw || raw.length < 4) {
+    return { ok: false, error: `Invalid session_id "${ref}"` };
+  }
+  const compact = raw.replace(/-/g, "").toLowerCase();
+  const topicKey = topicCwd
+    ? topicCwd.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase()
+    : "";
+
+  // Exact get first.
+  const exact = store.get(raw) ?? store.get(raw.toLowerCase());
+  if (exact) return { ok: true, sessionId: exact.sessionId, cwd: exact.cwd || undefined };
+
+  let metas;
+  try {
+    metas = store.list(200);
+  } catch {
+    return { ok: false, error: `Session store unreadable for "${ref}"` };
+  }
+
+  const matches = metas.filter((m) => {
+    const id = m.sessionId.toLowerCase();
+    const idCompact = id.replace(/-/g, "");
+    return (
+      id === raw.toLowerCase() ||
+      id.startsWith(raw.toLowerCase()) ||
+      idCompact.startsWith(compact) ||
+      idCompact.includes(compact)
+    );
+  });
+  if (matches.length === 0) {
+    return {
+      ok: false,
+      error: `No session found for session_id "${ref}". Use a full id or longer prefix from memory hits.`,
+    };
+  }
+  // Prefer path under the topic project, then most recently updated.
+  matches.sort((a, b) => {
+    const aPath = (a.cwd || "").replace(/\\/g, "/").toLowerCase();
+    const bPath = (b.cwd || "").replace(/\\/g, "/").toLowerCase();
+    const aIn =
+      topicKey && (aPath === topicKey || aPath.startsWith(topicKey + "/")) ? 1 : 0;
+    const bIn =
+      topicKey && (bPath === topicKey || bPath.startsWith(topicKey + "/")) ? 1 : 0;
+    if (bIn !== aIn) return bIn - aIn;
+    return String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""));
+  });
+  const best = matches[0]!;
+  return { ok: true, sessionId: best.sessionId, cwd: best.cwd || undefined };
+}
+
+/** True when the model used a non-topic placeholder like "…" or "TODO". */
+export function isPlaceholderTopicRef(ref: string): boolean {
+  const t = ref.trim().toLowerCase();
+  if (!t) return true;
+  // Any pure punctuation / ellipsis run (incl. multi-char "……" and fullwidth).
+  if (/^[\s.…·•⋯︙\-–—_*~`'"“”‘’\u2026\u22ef\u3002]+$/u.test(t)) return true;
+  if (t.includes("…") && t.replace(/[.…\s]/g, "").length === 0) return true;
+  if (t === "..." || t === "…" || t === "topic" || t === "name" || t === "project") return true;
+  if (t === "todo" || t === "tbd" || t === "null" || t === "undefined" || t === "none") return true;
+  if (t === "here" || t === "there" || t === "same" || t === "related" || t === "target") return true;
+  if (t === "the topic" || t === "that topic" || t === "this topic") return true;
+  return false;
+}
+
+function safeListTopics(forum: ForumManager): Array<{
+  threadId: number;
+  name: string;
+  kind: string;
+  projectPath?: string;
+}> {
+  try {
+    return forum.store.all().map((t) => ({
+      threadId: t.threadId,
+      name: t.name,
+      kind: t.kind,
+      projectPath: t.projectPath ?? undefined,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * When the model omits topic / uses "…" / wrong name, pick the best forum topic
+ * (+ optional session) from group memory using the user ask and prompt body.
+ */
+export function inferDispatchTarget(
+  ctx: Pick<TelegramActionContext, "store" | "cfg" | "managerUserAskPreview">,
+  forum: ForumManager,
+  queryParts: string[],
+): { binding: ForumTopicBinding; sessionId?: string; cwd?: string } | undefined {
+  const query = queryParts
+    .map((s) => (s || "").trim())
+    .filter(Boolean)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .slice(0, 400);
+  if (query.length < 3) return undefined;
+
+  let topics: ForumTopicBinding[] = [];
+  try {
+    topics = forum.store.all();
+  } catch {
+    return undefined;
+  }
+  if (topics.length === 0) return undefined;
+
+  const preferPaths = topics
+    .filter((t) => t.kind === "project" && t.projectPath)
+    .map((t) => t.projectPath!)
+    .slice(0, 30);
+
+  let hits;
+  try {
+    hits = searchGroupMemory({
+      query,
+      limit: 16,
+      sessionsDir: ctx.cfg.sessionsDir,
+      store: ctx.store,
+      topics,
+      preferPaths,
+      preferGeneral: false,
+      maxSessions: 80,
+    });
+  } catch {
+    return undefined;
+  }
+  if (!hits.length) return undefined;
+
+  // 1) Session / history hit → path → topic (prefer resume for follow-ups).
+  for (const h of hits) {
+    if (!h.sessionId) continue;
+    let path = h.path;
+    if (!path) {
+      try {
+        path = ctx.store.get(h.sessionId)?.cwd;
+      } catch {
+        path = undefined;
+      }
+    }
+    if (!path) continue;
+    const b = resolveTopicFromPath(forum, path);
+    if (!b?.projectPath || b.kind === "general") continue;
+    const sess = resolveSessionRef(ctx.store, h.sessionId, path);
+    return {
+      binding: b,
+      sessionId: sess.ok ? sess.sessionId : h.sessionId,
+      cwd: (sess.ok && sess.cwd) || path,
     };
   }
+
+  // 2) Direct topic hit (project preferred), then attach newest session under path.
+  for (const h of hits) {
+    if (h.kind !== "topic" || h.threadId === undefined) continue;
+    const b = forum.store.get(h.threadId);
+    if (!b?.projectPath) continue;
+    if (b.kind === "general") continue;
+    const under = newestSessionUnderPath(ctx.store, b.projectPath);
+    if (under) {
+      return { binding: b, sessionId: under.sessionId, cwd: under.cwd || b.projectPath };
+    }
+    return { binding: b };
+  }
+
+  // 3) Unique project-topic name token match from query.
+  const qn = normalizeTopicKey(query);
+  const nameHits = topics.filter((t) => {
+    if (t.kind === "general" || !t.projectPath) return false;
+    const tn = normalizeTopicKey(t.name);
+    return tn.length >= 4 && (qn.includes(tn) || tn.includes(qn.slice(0, Math.min(12, qn.length))));
+  });
+  if (nameHits.length === 1) {
+    const b = nameHits[0]!;
+    const under = newestSessionUnderPath(ctx.store, b.projectPath!);
+    if (under) {
+      return { binding: b, sessionId: under.sessionId, cwd: under.cwd || b.projectPath || undefined };
+    }
+    return { binding: b };
+  }
+
+  return undefined;
+}
+
+function newestSessionUnderPath(
+  store: SessionStore,
+  projectPath: string,
+): { sessionId: string; cwd?: string } | undefined {
+  const key = normPath(projectPath);
+  if (!key) return undefined;
+  let metas;
+  try {
+    metas = store.list(80);
+  } catch {
+    return undefined;
+  }
+  const under = metas
+    .filter((m) => {
+      const p = normPath(m.cwd || "");
+      return p === key || p.startsWith(key + "/");
+    })
+    .sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
+  const best = under[0];
+  if (!best) return undefined;
+  return { sessionId: best.sessionId, cwd: best.cwd || undefined };
+}
+
+function normalizeTopicKey(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+
+/** Map a session/project path to a forum topic binding (exact path, then parent). */
+export function resolveTopicFromPath(
+  forum: ForumManager,
+  cwd: string,
+): ForumTopicBinding | undefined {
+  const key = normPath(cwd);
+  if (!key) return undefined;
+  const all = forum.store.all().filter((t) => t.projectPath);
+  // Exact path match first.
+  const exact = all.filter((t) => normPath(t.projectPath!) === key);
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) {
+    // Prefer project kind over general/ai_chat.
+    const proj = exact.find((t) => t.kind === "project");
+    return proj || exact[0];
+  }
+  // Session cwd may be a subfolder of the bound project path.
+  const parents = all.filter((t) => {
+    const tp = normPath(t.projectPath!);
+    return key === tp || key.startsWith(tp + "/");
+  });
+  if (parents.length === 0) {
+    // Or topic path is under session cwd (less common).
+    const children = all.filter((t) => {
+      const tp = normPath(t.projectPath!);
+      return tp.startsWith(key + "/");
+    });
+    if (children.length === 1) return children[0];
+    if (children.length > 1) {
+      children.sort((a, b) => normPath(a.projectPath!).length - normPath(b.projectPath!).length);
+      return children[0];
+    }
+    return undefined;
+  }
+  // Longest matching project path wins.
+  parents.sort((a, b) => normPath(b.projectPath!).length - normPath(a.projectPath!).length);
+  const topLen = normPath(parents[0]!.projectPath!).length;
+  const top = parents.filter((t) => normPath(t.projectPath!).length === topLen);
+  if (top.length === 1) return top[0];
+  return top.find((t) => t.kind === "project") || top[0];
+}
+
+function listTopicHints(forum: ForumManager, limit = 12): string {
+  try {
+    const topics = forum.store.all().slice(0, limit);
+    if (topics.length === 0) return "";
+    return topics.map((t) => `«${t.name}» #${t.threadId}`).join(", ");
+  } catch {
+    return "";
+  }
 }
 
 /**
- * Resolve a topic ref: numeric / #id, "general", "ai chat", or exact title.
+ * Resolve a topic ref: numeric / #id, "general", "ai chat", exact title,
+ * or fuzzy (prefix / contains / normalized) when unique.
  */
 export function resolveTopicRef(
   forum: ForumManager,
@@ -268,7 +776,12 @@ export function resolveTopicRef(
   cfg: AppConfig,
 ): { ok: true; binding: ForumTopicBinding } | { ok: false; error: string } {
   const raw = ref.trim();
-  if (!raw) return { ok: false, error: "Empty topic reference" };
+  if (!raw || isPlaceholderTopicRef(raw)) {
+    return {
+      ok: false,
+      error: `Empty or placeholder topic "${raw || "…"}". Use exact title, #threadId, "general", or "ai chat".`,
+    };
+  }
 
   // #123 or plain digits
   const idMatch = /^#?(\d+)$/.exec(raw);
@@ -305,8 +818,10 @@ export function resolveTopicRef(
     return { ok: false, error: "AI Chat topic not found — run /forum_setup" };
   }
 
+  const all = forum.store.all();
+
   // Exact title match (case-insensitive)
-  const hits = forum.store.all().filter((t) => t.name.toLowerCase() === key);
+  const hits = all.filter((t) => t.name.toLowerCase() === key);
   if (hits.length === 1) return { ok: true, binding: hits[0]! };
   if (hits.length > 1) {
     return {
@@ -314,9 +829,54 @@ export function resolveTopicRef(
       error: `Multiple topics named "${raw}" (${hits.map((h) => "#" + h.threadId).join(", ")}). Use #threadId.`,
     };
   }
+
+  // Fuzzy: starts-with / includes / normalized alphanumeric.
+  // Require at least 3 useful chars to avoid accidental matches.
+  const keyN = normalizeTopicKey(raw);
+  if (keyN.length >= 3 || key.length >= 3) {
+    const scored = all
+      .map((t) => {
+        const n = t.name.toLowerCase();
+        const nn = normalizeTopicKey(t.name);
+        let score = 0;
+        if (n === key || nn === keyN) score = 100;
+        else if (n.startsWith(key) || nn.startsWith(keyN)) score = 80;
+        else if (key.startsWith(n) && n.length >= 3) score = 70;
+        else if (n.includes(key) || (keyN.length >= 4 && nn.includes(keyN))) score = 50;
+        else if (keyN.length >= 4 && keyN.includes(nn) && nn.length >= 4) score = 40;
+        return { t, score };
+      })
+      .filter((x) => x.score > 0)
+      .sort((a, b) => b.score - a.score || a.t.name.length - b.t.name.length);
+
+    if (scored.length === 1 && scored[0]!.score >= 40) {
+      return { ok: true, binding: scored[0]!.t };
+    }
+    if (scored.length > 1) {
+      const best = scored[0]!.score;
+      const top = scored.filter((x) => x.score === best);
+      if (top.length === 1 && best >= 70) {
+        return { ok: true, binding: top[0]!.t };
+      }
+      return {
+        ok: false,
+        error:
+          `Ambiguous topic "${raw}" — matches: ` +
+          top
+            .slice(0, 6)
+            .map((x) => `«${x.t.name}» #${x.t.threadId}`)
+            .join(", ") +
+          ". Use exact title or #threadId.",
+      };
+    }
+  }
+
+  const hint = listTopicHints(forum);
   return {
     ok: false,
-    error: `Topic not found: "${raw}". Use exact title, #threadId, "general", or "ai chat".`,
+    error:
+      `Topic not found: "${raw}". Use exact title, #threadId, "general", or "ai chat".` +
+      (hint ? ` Available: ${hint}` : ""),
   };
 }
 
@@ -325,21 +885,85 @@ function searchMemory(
   ctx: TelegramActionContext,
 ): TelegramActionResult {
   const topics = ctx.forum?.isReady ? ctx.forum.store.all() : undefined;
+  const workspace =
+    topics?.find((t) => t.kind === "general")?.projectPath ||
+    topics?.find((t) => t.kind === "ai_chat")?.projectPath ||
+    ctx.cfg.workspace;
+  const preferPaths = [
+    workspace,
+    ...(topics ?? [])
+      .filter((t) => t.kind === "project" && t.projectPath)
+      .map((t) => t.projectPath!)
+      .slice(0, 20),
+  ];
   const hits = searchGroupMemory({
     query: action.query,
-    limit: action.limit,
+    limit: action.limit ?? 14,
     sessionsDir: ctx.cfg.sessionsDir,
     store: ctx.store,
     topics,
+    preferPaths,
+    preferGeneral: !!ctx.managerMode,
+    maxSessions: ctx.managerMode ? 80 : 50,
   });
   return {
     action: "search_memory",
     ok: true,
-    data: { query: action.query, hits },
-    userNote:
-      hits.length > 0
-        ? `\u{1F50D} Memory search: ${hits.length} hit(s) for \u201c${action.query.slice(0, 60)}\u201d`
-        : `\u{1F50D} Memory search: no hits for \u201c${action.query.slice(0, 60)}\u201d`,
+    data: {
+      query: action.query,
+      hits,
+      note:
+        "Hits ranked by relevance + recency (newest sessions/history first). " +
+        "Snippets may include [age]. Prefer the newest session for a project path. " +
+        "When following up on a hit, pass its sessionId as send_prompt.session_id " +
+        "(full id or first 8 chars) so the bridge resumes that session, not the topic foreground. " +
+        (ctx.managerMode ? "Use before git." : ""),
+    },
+    // Silent in chat (manager or not) — results go to the agent.
+    userNote: undefined,
+  };
+}
+
+function listTopics(ctx: TelegramActionContext): TelegramActionResult {
+  const forum = ctx.forum;
+  if (!forum?.isReady) {
+    return {
+      action: "list_topics",
+      ok: true,
+      data: { topics: [], note: "Forum not ready" },
+    };
+  }
+  const topics = forum.store.all().map((t) => ({
+    threadId: t.threadId,
+    name: t.name,
+    kind: t.kind,
+    projectPath: t.projectPath,
+    sessionId: t.sessionId,
+  }));
+  return {
+    action: "list_topics",
+    ok: true,
+    data: { topics, count: topics.length },
+  };
+}
+
+function listJobs(): TelegramActionResult {
+  const jobs = listRecentManagerJobs(20).map((j) => ({
+    id: j.id,
+    status: j.status,
+    targetName: j.targetName,
+    targetThreadId: j.targetThreadId,
+    targetPath: j.targetPath,
+    childSessionId: j.childSessionId,
+    userAskPreview: j.userAskPreview.slice(0, 160),
+    createdAt: j.createdAt,
+    updatedAt: j.updatedAt,
+    resultSummary: j.resultSummary?.slice(0, 200),
+  }));
+  return {
+    action: "list_jobs",
+    ok: true,
+    data: { jobs, count: jobs.length },
   };
 }
 
@@ -438,3 +1062,69 @@ async function botCommand(
     userNote: `\u{1F916} @${action.bot} /${action.command} \u2014 reply ready (${res.reply.length} chars)${partialNote}`,
   };
 }
+
+/** Telegram hard cap; leave headroom for UTF-16 / markup surprises. */
+const TG_MSG_SAFE = 4000;
+
+/**
+ * Split a bridge prompt into Telegram-safe announce parts (full coverage, no crop).
+ * Exported for tests — agent still receives the unsplit string separately.
+ */
+export function splitBridgeAnnounceParts(
+  prompt: string,
+  newSession: boolean,
+  sessNote = "",
+): string[] {
+  const flag = newSession ? " (new session)" : "";
+  const note = sessNote || "";
+  const singleHeader = `\u{1F4E8} Prompt from bridge${flag}${note} (${prompt.length} chars)\n\n`;
+  if (singleHeader.length + prompt.length <= TG_MSG_SAFE) {
+    return [singleHeader + prompt];
+  }
+  // Conservative body size so part headers never push over TG_MSG_SAFE.
+  const BODY = 3400;
+  const total = Math.max(1, Math.ceil(prompt.length / BODY));
+  const parts: string[] = [];
+  for (let i = 0; i < total; i++) {
+    const chunk = prompt.slice(i * BODY, (i + 1) * BODY);
+    const prefix =
+      i === 0
+        ? `\u{1F4E8} Prompt from bridge${flag}${note} (part 1/${total}, ${prompt.length} chars)\n\n`
+        : `\u{1F4E8} Prompt from bridge (part ${i + 1}/${total})\n\n`;
+    const full = prefix + chunk;
+    if (full.length <= TG_MSG_SAFE) {
+      parts.push(full);
+    } else {
+      const room = Math.max(500, TG_MSG_SAFE - prefix.length);
+      for (let o = 0; o < chunk.length; o += room) {
+        parts.push(prefix + chunk.slice(o, o + room));
+      }
+    }
+  }
+  return parts;
+}
+
+/**
+ * Post the bridge prompt into the target topic for humans to read.
+ * Splits across multiple Telegram messages (4096 hard limit) so long
+ * orchestration prompts are not silently cropped in the topic UI.
+ * The agent still receives the full unsplit string via submitTopicPrompt.
+ */
+async function announceBridgePrompt(
+  api: Api,
+  chatId: number,
+  threadId: number,
+  prompt: string,
+  newSession: boolean,
+  sessNote = "",
+): Promise<void> {
+  const thread = outboundThreadExtra(threadId);
+  const parts = splitBridgeAnnounceParts(prompt, newSession, sessNote);
+  try {
+    for (const part of parts) {
+      await api.sendMessage(chatId, part, thread);
+    }
+  } catch (e) {
+    log.debug(`send_prompt announce failed: ${(e as Error).message}`);
+  }
+}