grok-telegram-bot 2.4.0 → 2.6.0

package/src/render/tool-call.ts

@@ -159,7 +159,24 @@ function formatByKind(
   }
 }
 
-// ---- helpers for code fences ----
+// ---- helpers for code fences / path labels ----
+
+/**
+ * File paths in **bold** break Telegram MarkdownV2 (Windows `\`, dots, long
+ * session paths). Always put paths in inline code; keep only the verb bold.
+ *   ✏️ **Edit** `C:\Users\…\plan.md`
+ */
+function pathCode(path: string | undefined | null, fallback = "file"): string {
+  const p = (path || "").trim() || fallback;
+  // Inline code cannot contain raw backticks unescaped in our MD pipeline;
+  // replace rare ` in paths so the span stays closed.
+  return "`" + p.replace(/`/g, "'") + "`";
+}
+
+/** `**Edit** \`path\`` style header fragment (no leading emoji). */
+function boldVerbPath(verb: string, path: string | undefined | null, fallback = "file"): string {
+  return "**" + verb + "** " + pathCode(path, fallback);
+}
 
 /** Fence that lengthens itself when the body contains backticks (avoids MD break). */
 function fence(text: string, lang?: string): string {
@@ -197,8 +214,8 @@ function formatExecute(
 ): string {
   const cmd = extractCommand(raw);
   const cwd = strOf(raw.cwd) || strOf(raw.working_directory) || strOf(raw.workingDirectory);
-  const title = "Run command" + (cwd ? " in " + truncate(cwd, 80) : "");
-  let out = "\u{1F4BB} **" + title + "**" + tail;
+  let out = "\u{1F4BB} **Run command**" + tail;
+  if (cwd) out += " in " + pathCode(truncate(cwd, 80));
   if (toolName && toolName !== "execute" && toolName !== "shell" && toolName !== "bash") {
     out += `\n  tool: \`${toolName}\``;
   }
@@ -226,8 +243,7 @@ function formatEdit(
   toolName: string,
 ): string {
   const path = extractPath(raw);
-  const title = "Edit " + (path || "file");
-  let out = "\u270F\uFE0F **" + title + "**" + tail;
+  let out = "\u270F\uFE0F " + boldVerbPath("Edit", path) + tail;
   if (toolName && !/edit|replace/i.test(toolName)) out += `\n  tool: \`${toolName}\``;
   if (opts.showDiffs) {
     const diff = buildEditDiff(u, raw, opts.diffMaxLines);
@@ -242,7 +258,7 @@ function formatEdit(
 function formatWrite(u: SessionUpdate, kind: string, raw: Record<string, unknown>, tail: string): string {
   const path = extractPath(raw);
   const verb = kind === "create" ? "Create" : "Write";
-  let out = "\u{1F4DD} **" + verb + " " + (path || "file") + "**" + tail;
+  let out = "\u{1F4DD} " + boldVerbPath(verb, path) + tail;
   const content = extractContent(raw) || extractToolOutput(u);
   if (content) {
     out += "\n" + fence(truncateMiddleLines(content, OUTPUT_PREVIEW_LINES, CONTENT_PREVIEW_MAX), detectLang(path)) + "\n";
@@ -258,14 +274,13 @@ function formatRead(
 ): string {
   const path = extractPath(raw, u);
   const range = extractReadRange(raw);
-  let title = "Read " + (path || "file");
   const parts: string[] = [];
   if (range.startLine) parts.push("line " + range.startLine);
   if (range.offset) parts.push("offset " + range.offset);
   if (range.limit) parts.push("limit " + range.limit);
   if (range.pages) parts.push("pages " + range.pages);
-  if (parts.length) title += " (" + parts.join(", ") + ")";
-  let out = "\u{1F4D6} **" + title + "**" + tail;
+  let out = "\u{1F4D6} " + boldVerbPath("Read", path) + tail;
+  if (parts.length) out += " (" + parts.join(", ") + ")";
   if (toolName && toolName !== "read" && toolName !== "read_file") {
     out += `\n  tool: \`${toolName}\``;
   }
@@ -292,11 +307,11 @@ function formatList(
     strOf(raw.target_directory) ||
     strOf(raw.targetDirectory) ||
     ".";
-  let out = "\u{1F4C1} **List " + truncate(path, 120) + "**" + tail;
+  let out = "\u{1F4C1} " + boldVerbPath("List", truncate(path, 120), ".") + tail;
   if (toolName) out += `\n  tool: \`${toolName}\``;
   const filters = extractFilters(raw);
-  if (filters.include) out += "\n  include: " + filters.include;
-  if (filters.exclude) out += "\n  exclude: " + filters.exclude;
+  if (filters.include) out += "\n  include: `" + filters.include.replace(/`/g, "'") + "`";
+  if (filters.exclude) out += "\n  exclude: `" + filters.exclude.replace(/`/g, "'") + "`";
   const body = extractToolOutput(u);
   if (body) {
     out += "\n" + fence(truncateMiddleLines(body, OUTPUT_PREVIEW_LINES, OUTPUT_PREVIEW_MAX)) + "\n";
@@ -314,16 +329,16 @@ function formatSearch(
   const path = extractSearchPath(raw);
   const filters = extractFilters(raw);
   const isGlob = /glob/i.test(toolName) || (!!filters.include && !query);
-  let title = isGlob ? "Glob" : "Search";
-  if (query) title += ": " + truncate(query, 120);
-  else if (path) title += " " + path;
-  let out = "\u{1F50E} **" + title + "**" + tail;
+  const verb = isGlob ? "Glob" : "Search";
+  let out = "\u{1F50E} **" + verb + "**" + tail;
+  if (query) out += " " + pathCode(truncate(query, 120), "query");
+  else if (path) out += " " + pathCode(truncate(path, 120));
   if (toolName && toolName !== "search" && toolName !== "grep") {
     out += `\n  tool: \`${toolName}\``;
   }
-  if (path && !(query && query.includes(path))) out += "\n  \u{1F4C2} in: " + truncate(path, 100);
-  if (filters.include) out += "\n  \u{1F4C1} include: " + filters.include;
-  if (filters.exclude) out += "\n  \u{1F6AB} exclude: " + filters.exclude;
+  if (path && query) out += "\n  \u{1F4C2} in: " + pathCode(truncate(path, 100));
+  if (filters.include) out += "\n  \u{1F4C1} include: " + pathCode(filters.include);
+  if (filters.exclude) out += "\n  \u{1F6AB} exclude: " + pathCode(filters.exclude);
   if (raw.case_sensitive !== undefined) {
     out += "\n  case-sensitive: " + (raw.case_sensitive ? "yes" : "no");
   }
@@ -338,7 +353,7 @@ function formatSearch(
 
 function formatDelete(raw: Record<string, unknown>, tail: string): string {
   const path = extractPath(raw);
-  return "\u{1F5D1}\uFE0F **Delete " + (path || "file") + "**" + tail;
+  return "\u{1F5D1}\uFE0F " + boldVerbPath("Delete", path) + tail;
 }
 
 function formatMove(kind: string, raw: Record<string, unknown>, tail: string): string {
@@ -352,20 +367,20 @@ function formatMove(kind: string, raw: Record<string, unknown>, tail: string): s
       "**" +
       tail +
       "\n  \u{1F4C4} " +
-      truncate(src, 100) +
+      pathCode(truncate(src, 100)) +
       "\n  \u27A1\uFE0F " +
-      truncate(dst, 100)
+      pathCode(truncate(dst, 100))
     );
   }
-  return "\u{1F4E6} **" + verb + " " + (src || dst || "file") + "**" + tail;
+  return "\u{1F4E6} " + boldVerbPath(verb, src || dst) + tail;
 }
 
 function formatFetch(u: SessionUpdate, raw: Record<string, unknown>, tail: string): string {
   const url = extractUrl(raw);
   const method = strOf(raw.method) || strOf(raw.verb) || "GET";
-  let title = "Fetch URL";
-  if (url) title = "Fetch " + truncate(url, 200);
-  let out = "\u{1F310} **" + title + "**" + tail;
+  let out = url
+    ? "\u{1F310} **Fetch** " + pathCode(truncate(url, 200), "URL") + tail
+    : "\u{1F310} **Fetch URL**" + tail;
   if (method && method !== "GET") out += "\n  method: " + method;
   const headers = raw.headers;
   if (headers && typeof headers === "object") {
@@ -384,9 +399,8 @@ function formatFetch(u: SessionUpdate, raw: Record<string, unknown>, tail: strin
 function formatWebSearch(u: SessionUpdate, raw: Record<string, unknown>, tail: string): string {
   const query = extractSearchQuery(raw) || extractUrl(raw);
   const count = strOf(raw.count) || strOf(raw.num) || strOf(raw.num_results) || numStr(raw.num_results);
-  let title = "Web search";
-  if (query) title += ": " + truncate(query, 150);
-  let out = "\u{1F310} **" + title + "**" + tail;
+  let out = "\u{1F310} **Web search**" + tail;
+  if (query) out += " " + pathCode(truncate(query, 150), "query");
   if (count) out += "\n  results: " + count;
   const result = extractToolOutput(u);
   if (result) {
@@ -428,7 +442,7 @@ function formatImage(raw: Record<string, unknown>, tail: string, toolName: strin
   const path = extractPath(raw) || strOf(raw.image) || strOf(raw.output);
   let out = "\u{1F5BC}\uFE0F **Image**" + tail;
   if (toolName) out += `\n  tool: \`${toolName}\``;
-  if (path) out += "\n  " + truncate(path, 200);
+  if (path) out += "\n  " + pathCode(truncate(path, 200));
   const prompt = strOf(raw.prompt);
   if (prompt) out += "\n  prompt: " + truncate(prompt, 200);
   return out;
@@ -482,27 +496,32 @@ function formatGeneric(
   const path = extractPath(raw);
   const cmd = extractCommand(raw);
   const query = extractSearchQuery(raw);
-  // Never show a bare "Other" / "Tool call" — prefer real tool name / path / cmd.
+  // Never show a bare "Other" / "Tool call" — prefer real tool name. Paths/queries
+  // go in inline code (not bold) so Windows paths cannot break MarkdownV2.
   let label =
     (toolName && !/^tool[_ ]?call$/i.test(toolName) ? toolName : "") ||
     (u.title && !/^other$/i.test(u.title.trim()) && !/^tool[_ ]?call$/i.test(u.title.trim())
       ? u.title.trim()
       : "") ||
-    (path ? capitalize(kind !== "other" ? kind : "use") + " " + path : "") ||
+    (path ? capitalize(kind !== "other" ? kind : "use") : "") ||
     (cmd ? "Run command" : "") ||
-    (query ? "Search: " + truncate(query, 80) : "") ||
+    (query ? "Search" : "") ||
     (kind && kind !== "other" ? capitalize(kind) : "") ||
     (toolName || "Tool");
   if (/^other$/i.test(label) || /^tool[_ ]?call$/i.test(label)) {
-    label = toolName && !/^tool[_ ]?call$/i.test(toolName) ? toolName : path || cmd || query || "Tool";
+    label = toolName && !/^tool[_ ]?call$/i.test(toolName) ? toolName : "Tool";
+  }
+  // Titles that accidentally embed a path stay short: drop path from bold label.
+  if (path && label.includes(path)) {
+    label = label.replace(path, "").replace(/\s+/g, " ").trim() || capitalize(kind !== "other" ? kind : "Tool");
   }
 
   let out = icon + " **" + label + "**" + tail;
   if (toolName && toolName !== label) out += `\n  tool: \`${toolName}\``;
-  if (path && !label.includes(path)) out += "\n  \u{1F4C4} " + truncate(path, 120);
+  if (path) out += "\n  \u{1F4C4} " + pathCode(truncate(path, 120));
   if (cmd) out += "\n" + fence(truncateMiddle(cmd, PREVIEW_MAX), "bash") + "\n";
-  else if (query && !label.includes(query)) out += "\n  query: " + truncate(query, 150);
-  else {
+  else if (query) out += "\n  query: " + pathCode(truncate(query, 150), "query");
+  else if (!path && !cmd) {
     const args = formatArgLines(raw);
     if (args) out += "\n" + fence(truncateMiddle(args, PREVIEW_MAX)) + "\n";
   }

package/src/service/platform.ts

@@ -2,7 +2,7 @@
  * Platform detection, launch-spec construction, and a small command runner
  * shared by the per-OS service controllers.
  */
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { join } from "node:path";
 import { PROJECT_ROOT, INSTANCE_DIR } from "../config.js";
 
@@ -47,18 +47,55 @@ export function buildLaunchSpec(): LaunchSpec {
   };
 }
 
-/** Run a command, returning combined output. Throws on non-zero exit. */
-export function run(cmd: string, args: string[]): string {
-  return execFileSync(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+/** Default max wait for schtasks/systemctl/powershell helpers — never hang the CLI. */
+const RUN_TIMEOUT_MS = 45_000;
+
+/** Run a command, returning combined output. Throws on non-zero exit or timeout. */
+export function run(cmd: string, args: string[], timeoutMs = RUN_TIMEOUT_MS): string {
+  return execFileSync(cmd, args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
+  });
 }
 
 /** Run a command, swallowing errors and returning { ok, out }. */
-export function runSafe(cmd: string, args: string[]): { ok: boolean; out: string } {
+export function runSafe(cmd: string, args: string[], timeoutMs = RUN_TIMEOUT_MS): { ok: boolean; out: string } {
   try {
-    return { ok: true, out: run(cmd, args) };
+    return { ok: true, out: run(cmd, args, timeoutMs) };
   } catch (e) {
-    const err = e as { stdout?: Buffer | string; stderr?: Buffer | string; message?: string };
+    const err = e as {
+      stdout?: Buffer | string;
+      stderr?: Buffer | string;
+      message?: string;
+      killed?: boolean;
+      code?: string;
+    };
+    // Node sets killed=true when the timeout option aborts the child.
+    if (err.killed || err.code === "ETIMEDOUT") {
+      return { ok: false, out: `timed out after ${timeoutMs}ms: ${cmd} ${args.join(" ")}` };
+    }
     const out = String(err.stdout ?? "") + String(err.stderr ?? "") || err.message || "failed";
     return { ok: false, out };
   }
 }
+
+/**
+ * Fire-and-forget process (detached). Use for forever-restart supervisors
+ * (Windows VBS loop) so `grok-tg install|start|restart` does not hang waiting
+ * for a process that never exits.
+ */
+export function launchDetached(cmd: string, args: string[]): { ok: boolean; out: string } {
+  try {
+    const child = spawn(cmd, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.unref();
+    if (child.pid == null) return { ok: false, out: "spawn produced no pid" };
+    return { ok: true, out: `pid ${child.pid}` };
+  } catch (e) {
+    return { ok: false, out: (e as Error).message || "spawn failed" };
+  }
+}

package/src/service/windows.ts

@@ -8,7 +8,7 @@
  */
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { runSafe } from "./platform.js";
+import { launchDetached, runSafe } from "./platform.js";
 import type { LaunchSpec, ServiceController, ServiceResult } from "./types.js";
 
 const TASK = "GrokTelegramBot";
@@ -105,7 +105,11 @@ export const windowsController: ServiceController = {
     } catch (e) {
       return fail(`Startup-folder install failed: ${(e as Error).message}`);
     }
-    if (!isRunning(spec)) runSafe("wscript.exe", [startupVbs]); // launch now
+    // Detached: the VBS is a forever-restart loop — never wait on it (hangs install/start/restart).
+    if (!isRunning(spec)) {
+      const launched = launchDetached("wscript.exe", [startupVbs]);
+      if (!launched.ok) return fail(`Installed launcher but failed to start: ${launched.out}`);
+    }
     return ok(
       `Installed via the Startup folder — starts hidden at logon, no admin needed — and launched it.\n` +
         `(Tip: run "grok-tg install" from an elevated terminal to use a hidden Scheduled Task instead.)`,
@@ -124,13 +128,21 @@ export const windowsController: ServiceController = {
   async start(spec) {
     if (isRunning(spec)) return ok("Already running.");
     if (taskInstalled()) {
+      // schtasks /Run returns once the task is queued (does not wait for the bot).
       const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
       return res.ok ? ok("Started.") : fail(res.out);
     }
     const startupVbs = startupVbsPath();
     if (startupVbs && existsSync(startupVbs)) {
-      runSafe("wscript.exe", [startupVbs]);
-      return ok("Started.");
+      // Forever-restart VBS — must be detached or this CLI never returns.
+      const launched = launchDetached("wscript.exe", [startupVbs]);
+      return launched.ok ? ok("Started.") : fail(launched.out);
+    }
+    // Local run-service.vbs in the package dir (task points here when elevated).
+    const local = vbsPath(spec);
+    if (existsSync(local)) {
+      const launched = launchDetached("wscript.exe", [local]);
+      return launched.ok ? ok("Started.") : fail(launched.out);
     }
     return fail(`Not installed. Run "grok-tg install" first.`);
   },

package/src/sessions/history.ts

@@ -5,8 +5,20 @@
 import { closeSync, openSync, readSync, statSync } from "node:fs";
 import { IMAGE_OUTPUT_DIRECTIVE } from "../render/image-output.js";
 import { extractProgress, PROGRESS_DIRECTIVE } from "../render/progress.js";
+import {
+  extractTelegramActions,
+  TELEGRAM_BRIDGE_MARKER,
+  TELEGRAM_BRIDGE_RESULTS_MARKER,
+} from "../render/telegram-bridge.js";
+import {
+  MANAGER_DIRECTIVE_MARKER,
+  MANAGER_WORK_REPORT_MARKER,
+} from "../render/manager-directive.js";
 import type { HistoryEntry, HistoryRole } from "./types.js";
 
+/** Keep in sync with bot/manager-context.ts (avoid sessions→bot import). */
+const MANAGER_CONTEXT_MARKER = "MANAGER CONTEXT (auto — use before dispatching work):";
+
 const TAIL_WINDOWS = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024]; // grow until entries found
 
 interface RawEvent {
@@ -49,6 +61,7 @@ export function jsonlMtimeMs(jsonlPath: string): number {
 /**
  * Best-effort card blurb from the tail of a session log: last assistant prose
  * (what was solved), else last user prompt. Skips import-confirm noise.
+ * @deprecated Prefer {@link readLastUserPrompt} for session card comments.
  */
 export function readLastCardSummary(jsonlPath: string, maxEntries = 30): string {
   const entries = readHistory(jsonlPath, maxEntries);
@@ -71,7 +84,24 @@ export function readLastCardSummary(jsonlPath: string, maxEntries = 30): string
   return "";
 }
 
-function cleanCardProse(raw: string, max = 200): string {
+/**
+ * Last user prompt from the session log for card comments (newest → oldest).
+ * Strips complexity wrappers / import-confirm noise. Empty when none found.
+ */
+export function readLastUserPrompt(jsonlPath: string, maxEntries = 40, maxLen = 250): string {
+  const entries = readHistory(jsonlPath, maxEntries);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]!;
+    if (e.role !== "user" || !e.text.trim()) continue;
+    const t = cleanCardProse(e.text, maxLen);
+    if (!t) continue;
+    if (/session import complete/i.test(t)) continue;
+    return t;
+  }
+  return "";
+}
+
+function cleanCardProse(raw: string, max = 250): string {
   let t = extractProgress(raw).cleaned;
   t = t.replace(/```[\s\S]*?```/g, " ");
   t = t.replace(/^COMPLEXITY \(decide yourself[\s\S]*?User task:\s*/i, "");
@@ -203,23 +233,52 @@ function toEntry(ev: RawEvent): HistoryEntry | undefined {
 function cleanStoredText(text: string): string {
   if (!text) return text;
   let t = extractProgress(text).cleaned;
+  t = extractTelegramActions(t).cleaned;
   if (t.includes(PROGRESS_DIRECTIVE)) t = t.split(PROGRESS_DIRECTIVE).join("").trim();
   if (t.includes(IMAGE_OUTPUT_DIRECTIVE)) t = t.split(IMAGE_OUTPUT_DIRECTIVE).join("").trim();
-  // Strip first-prompt auto-complexity steering (and legacy forced-complex wrapper)
-  // so history / cards show the real user task, not bot plumbing.
-  const taskMarker = "User task:";
-  const ti = t.lastIndexOf(taskMarker);
-  if (
-    ti !== -1 &&
-    (/^COMPLEXITY \(decide yourself/i.test(t) || /^TASK COMPLEXITY:/i.test(t))
+  // Prefer "User task (continued):" BEFORE plain "User task:" — the continued
+  // marker contains the substring "User task:", so lastIndexOf("User task:")
+  // would slice into "(continued):…" and leak bridge teaching into cards/logs.
+  const cont = "User task (continued):";
+  const ci = t.lastIndexOf(cont);
+  if (ci !== -1) {
+    t = t.slice(ci + cont.length).trim();
+  } else if (
+    /^COMPLEXITY \(decide yourself/i.test(t) ||
+    /^TASK COMPLEXITY:/i.test(t)
   ) {
-    t = t.slice(ti + taskMarker.length).trim();
+    const taskMarker = "User task:";
+    const ti = t.indexOf(taskMarker);
+    if (ti !== -1) t = t.slice(ti + taskMarker.length).trim();
+  }
+  // Strip leftover telegram bridge teaching if still present (directive-only wrap).
+  if (t.includes(TELEGRAM_BRIDGE_MARKER)) {
+    const mi = t.indexOf(TELEGRAM_BRIDGE_MARKER);
+    if (mi === 0) {
+      const after = t.slice(TELEGRAM_BRIDGE_MARKER.length);
+      const dbl = after.search(/\n\n(?![-*`])/);
+      t = dbl !== -1 ? after.slice(dbl).trim() : "";
+    } else {
+      t = t.slice(0, mi).trim();
+    }
   }
   // Drop removed/quiet meta-prompts if they landed in history.
   if (/^Session status update \(meta only\)/i.test(t.trim())) t = "";
   if (/^FOLLOW-UP SUGGESTIONS \(meta only\)/i.test(t.trim())) t = "";
   if (/^SELF-RECHECK DECISION \(meta only\)/i.test(t.trim())) t = "";
   if (/^SELF-RECHECK \(automatic quality pass/i.test(t.trim())) t = "";
+  if (t.trimStart().startsWith(TELEGRAM_BRIDGE_RESULTS_MARKER)) t = "";
+  if (t.trimStart().startsWith(MANAGER_WORK_REPORT_MARKER)) t = "";
+  // Manager directive / context: keep only the user message tail.
+  if (t.includes(MANAGER_CONTEXT_MARKER)) {
+    const split = t.split(/\n---\n\n/);
+    if (split.length > 1) t = split.slice(1).join("\n---\n\n").trim();
+  }
+  if (t.includes(MANAGER_DIRECTIVE_MARKER)) {
+    const um = "User message:";
+    const ui = t.lastIndexOf(um);
+    if (ui !== -1) t = t.slice(ui + um.length).trim();
+  }
   return t;
 }
 

package/src/sessions/process.ts

@@ -16,6 +16,13 @@ const log = createLogger("sessions:process");
  */
 export function killPid(pid: number): boolean {
   if (!Number.isInteger(pid) || pid <= 0) return false;
+  // Never kill this bot process (or a mistaken self-target). Session locks for
+  // multiplexed ACP turns store the child agent pid, not node — but a recycled
+  // or mis-attributed lock must not take the Telegram poller down.
+  if (pid === process.pid) {
+    log.warn(`refusing to kill pid ${pid} (this bot process)`);
+    return false;
+  }
   try {
     if (process.platform === "win32") {
       execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });

package/src/sessions/types.ts

@@ -14,8 +14,8 @@ export interface SessionMeta {
   /** Size of the .jsonl history in bytes (proxy for conversation length). */
   historyBytes: number;
   /**
-   * Short status line for cards: current step while working, or chat summary
-   * when idle (persisted by the bot after turns).
+   * Short status for cards: last user prompt (persisted by the bot). While a
+   * turn is live, runtime may append last agent thinking as a second line.
    */
   comment?: string;
 }

package/src/stream/streamer.ts

@@ -15,8 +15,10 @@ import { chunkMarkdown } from "../render/chunk.js";
 import { toTelegramMarkdown } from "../render/markdown.js";
 import { extractProgress, progressBar } from "../render/progress.js";
 import { estimateProgress } from "../render/progress-estimate.js";
+import { stripTelegramActionFences } from "../render/telegram-bridge.js";
 import { truncateMiddle } from "../render/truncate.js";
 import { safeEdit, safeSend } from "../bot/telegram-io.js";
+import { outboundThreadExtra } from "../forum/thread.js";
 
 const SOFT_LIMIT = 3500;
 /** Display budget for a thinking block (middle-truncated; session context keeps all). */
@@ -30,6 +32,18 @@ interface Seg {
   toolId?: string;
 }
 
+export interface StreamerOptions {
+  /** Chat-like mode: drop thoughts/tools/plan; only stream agent prose. */
+  proseOnly?: boolean;
+  /** When false, never render a progress bar (manager chat). Default true. */
+  showProgressBar?: boolean;
+  /**
+   * Pre-posted message id to edit in place (e.g. General "Thinking…" placeholder).
+   * Avoids a separate bubble when the first real tokens arrive.
+   */
+  seedMessageId?: number;
+}
+
 export class ResponseStreamer {
   private readonly segs: Seg[] = [];
   private sealedIdx = 0;
@@ -53,6 +67,8 @@ export class ResponseStreamer {
    * the progress bar when set — done / in-progress / pending steps.
    */
   private planMarkdown: string | undefined;
+  private readonly proseOnly: boolean;
+  private readonly showProgressBar: boolean;
 
   constructor(
     private readonly api: Api,
@@ -65,7 +81,14 @@ export class ResponseStreamer {
     private readonly fallbackEnabled = false,
     /** Turn start time, used by the fallback's elapsed-time signal. */
     private readonly turnStartedAt = Date.now(),
-  ) {}
+    /** Forum topic thread — required so stream edits land in the right topic. */
+    private readonly messageThreadId?: number,
+    opts?: StreamerOptions,
+  ) {
+    this.proseOnly = !!opts?.proseOnly;
+    this.showProgressBar = opts?.showProgressBar !== false;
+    if (opts?.seedMessageId !== undefined) this.liveId = opts.seedMessageId;
+  }
 
   /** Replace the hashtag footer (used after a logical fork swaps the session id
    *  mid-turn, so the streamed response carries the NEW session's tags). */
@@ -73,15 +96,26 @@ export class ResponseStreamer {
     this.footer = footer;
   }
 
+  /** Seed/replace the live bubble id (General Thinking… placeholder). */
+  seedLiveMessage(messageId: number): void {
+    this.liveId = messageId;
+  }
+
+  /** Current live Telegram message id (for attaching suggestions after finalize). */
+  get liveMessageId(): number | undefined {
+    return this.liveId;
+  }
+
   /** "\n\n<footer>" appended to every finished message bubble (e.g. hashtags). */
   private footerSuffix(): string {
     return this.footer ? `\n\n${this.footer}` : "";
   }
 
-  /** Strip `{progress: N%}` markers from rendered text, remembering the latest
-   *  value (sticky across flushes) and notifying the owner when it changes. */
+  /** Strip `{progress: N%}` markers and telegram action JSON fences from
+   *  rendered text, remembering the latest progress value. */
   private captureProgress(text: string): string {
-    const { value, cleaned } = extractProgress(text);
+    const withoutTg = stripTelegramActionFences(text);
+    const { value, cleaned } = extractProgress(withoutTg);
     if (value !== undefined) this.setProgressValue(value, true);
     return cleaned;
   }
@@ -90,6 +124,7 @@ export class ResponseStreamer {
    *  and notifying the owner on change. Agent markers are authoritative: once
    *  one arrives, the bot fallback stops contributing. */
   private setProgressValue(pct: number, fromAgent: boolean): void {
+    if (!this.showProgressBar) return;
     if (fromAgent) this.agentReported = true;
     const next = Math.max(this.progress ?? 0, Math.round(pct));
     if (next === this.progress) return;
@@ -104,7 +139,7 @@ export class ResponseStreamer {
   /** Advance the fallback estimate from real activity signals, but only while
    *  the agent itself hasn't reported a value. No-op when fallback is off. */
   private applyFallback(): void {
-    if (!this.fallbackEnabled || this.agentReported) return;
+    if (!this.showProgressBar || !this.fallbackEnabled || this.agentReported) return;
     const est = estimateProgress({
       toolCalls: this.toolCalls,
       outputChars: this.outChars,
@@ -117,16 +152,24 @@ export class ResponseStreamer {
   /** Called when the turn finishes successfully: if the agent never reported
    *  its own progress, fill the fallback bar to 100. No-op otherwise. */
   completeFallback(): void {
-    if (!this.fallbackEnabled || this.agentReported) return;
+    if (!this.showProgressBar || !this.fallbackEnabled || this.agentReported) return;
     this.setProgressValue(100, false);
   }
 
+  private threadExtra(): Record<string, unknown> {
+    // Never send message_thread_id=1 (General) — Telegram rejects it.
+    return outboundThreadExtra(this.messageThreadId);
+  }
+
   /** reply_parameters threading EVERY message of the turn to the user's prompt,
    *  so the whole response (all bubbles, tool calls and continuations) stays in
-   *  one thread — not just the first message. */
+   *  one thread — not just the first message. Also carries forum topic id. */
   private replyExtra(): Record<string, unknown> {
-    if (this.replyTo === undefined) return {};
-    return { reply_parameters: { message_id: this.replyTo, allow_sending_without_reply: true } };
+    const extra: Record<string, unknown> = { ...this.threadExtra() };
+    if (this.replyTo !== undefined) {
+      extra.reply_parameters = { message_id: this.replyTo, allow_sending_without_reply: true };
+    }
+    return extra;
   }
 
   appendOutput(text: string): void {
@@ -137,7 +180,7 @@ export class ResponseStreamer {
   }
 
   appendThought(text: string): void {
-    if (!text) return;
+    if (!text || this.proseOnly) return;
     this.thoughtChars += text.length;
     this.merge("think", text);
     this.schedule();
@@ -148,7 +191,7 @@ export class ResponseStreamer {
    * for ACP tool calls that stream progress/output under a stable toolCallId.
    */
   addTool(rawMarkdown: string): void {
-    if (!rawMarkdown) return;
+    if (!rawMarkdown || this.proseOnly) return;
     this.toolCalls += 1;
     this.segs.push({ kind: "tool", text: rawMarkdown });
     this.schedule();
@@ -161,6 +204,7 @@ export class ResponseStreamer {
    */
   /** Replace the live plan board (or clear with empty/undefined). */
   setPlan(markdown: string | undefined): void {
+    if (this.proseOnly) return;
     const next = markdown?.trim() ? markdown.trim() : undefined;
     if (next === this.planMarkdown) return;
     this.planMarkdown = next;
@@ -168,7 +212,7 @@ export class ResponseStreamer {
   }
 
   upsertTool(toolId: string | undefined, rawMarkdown: string): void {
-    if (!rawMarkdown) return;
+    if (!rawMarkdown || this.proseOnly) return;
     const id = (toolId || "").trim();
     if (id) {
       // Replace any existing segment with this id (newest first; includes rare
@@ -193,8 +237,9 @@ export class ResponseStreamer {
     this.schedule();
   }
 
+  /** True when agent prose/tools/thoughts were appended (not just a seed bubble). */
   get hasOutput(): boolean {
-    return this.liveId !== undefined || this.segs.some((s) => s.text.trim().length > 0);
+    return this.segs.some((s) => s.text.trim().length > 0);
   }
 
   async finalize(): Promise<void> {
@@ -202,6 +247,8 @@ export class ResponseStreamer {
     if (this.timer) clearTimeout(this.timer);
     this.timer = undefined;
     await this.flush(true);
+    // Seeded Thinking… with zero agent text: leave the placeholder for the
+    // owner to replace (fallback reply) or keep while bridge results chain.
   }
 
   // ── internals ──────────────────────────────────────────────────────────────
@@ -240,8 +287,8 @@ export class ResponseStreamer {
       // Live bubble: body → plan (always above progress) → progress bar → footer.
       const parts: string[] = [];
       if (base.trim()) parts.push(base);
-      if (this.planMarkdown) parts.push(this.planMarkdown);
-      if (this.progress !== undefined) parts.push(progressBar(this.progress));
+      if (!this.proseOnly && this.planMarkdown) parts.push(this.planMarkdown);
+      if (this.showProgressBar && this.progress !== undefined) parts.push(progressBar(this.progress));
       if (parts.length === 0) return;
       const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
       const rendered = toTelegramMarkdown(src);