grok-telegram-bot 2.3.1 → 2.5.0

package/src/render/truncate.ts

@@ -0,0 +1,85 @@
+/**
+ * Display-only truncation helpers.
+ *
+ * Long tool outputs, diffs, and reasoning are shortened for Telegram so messages
+ * stay readable and under size limits. Session history / agent context is
+ * unaffected — these helpers never touch what is stored on disk for context.
+ */
+
+/** Ellipsis used in truncated regions (single character). */
+const ELLIPSIS = "\u2026";
+
+/**
+ * Keep the start of `text` when longer than `max` (classic head truncate).
+ * Prefer {@link truncateMiddle} for long command/diff/reasoning bodies.
+ */
+export function truncateHead(text: string, max: number): string {
+  if (max <= 0) return "";
+  if (text.length <= max) return text;
+  if (max === 1) return ELLIPSIS;
+  return text.slice(0, max - 1) + ELLIPSIS;
+}
+
+/**
+ * Keep both ends of a long string, cutting the middle with an explicit note.
+ * Head ~40% / tail ~60% of the budget so recent terminal output stays visible.
+ */
+export function truncateMiddle(text: string, max: number): string {
+  if (max <= 0) return "";
+  if (text.length <= max) return text;
+  if (max <= 24) return truncateHead(text, max);
+
+  const omitted = text.length;
+  const marker = `\n${ELLIPSIS} (${omitted.toLocaleString("en-US")} chars total; middle omitted) ${ELLIPSIS}\n`;
+  const budget = max - marker.length;
+  if (budget < 8) return truncateHead(text, max);
+
+  const headLen = Math.max(4, Math.floor(budget * 0.4));
+  const tailLen = Math.max(4, budget - headLen);
+  // Avoid overlapping when max is only slightly under length.
+  if (headLen + tailLen >= text.length) return text;
+  return text.slice(0, headLen) + marker + text.slice(text.length - tailLen);
+}
+
+/**
+ * Middle-truncate a multi-line block by whole lines when possible (better for
+ * diffs and command output). Falls back to character middle-truncate.
+ */
+export function truncateMiddleLines(text: string, maxLines: number, maxChars = 12_000): string {
+  const lines = text.split("\n");
+  let body: string;
+  if (lines.length <= maxLines) {
+    body = text;
+  } else {
+    const headN = Math.max(1, Math.floor(maxLines * 0.45));
+    const tailN = Math.max(1, maxLines - headN);
+    const omitted = lines.length - headN - tailN;
+    body = [
+      ...lines.slice(0, headN),
+      `${ELLIPSIS} (${omitted} lines omitted) ${ELLIPSIS}`,
+      ...lines.slice(lines.length - tailN),
+    ].join("\n");
+  }
+  return truncateMiddle(body, maxChars);
+}
+
+/**
+ * Live terminal display: keep the first output line + the last `tailLines`
+ * lines so long command runs update in place without spamming new blocks.
+ * Display-only — full text stays in the agent session / tool snapshot.
+ */
+export function formatLiveTerminalOutput(full: string, tailLines = 12, maxChars = 3500): string {
+  const normalized = full.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const lines = normalized.split("\n");
+  // Drop trailing empty lines for a cleaner tail.
+  while (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  if (lines.length === 0) return "";
+  if (lines.length <= tailLines + 1) {
+    return truncateMiddle(lines.join("\n"), maxChars);
+  }
+  const first = lines[0]!;
+  const tail = lines.slice(-tailLines);
+  const omitted = lines.length - 1 - tailLines;
+  const body = [first, `${ELLIPSIS} (${omitted} lines omitted; live tail) ${ELLIPSIS}`, ...tail].join("\n");
+  return truncateMiddle(body, maxChars);
+}

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.`);
   },
@@ -168,20 +180,32 @@ function entryOf(spec: LaunchSpec): string {
 }
 
 function vbsLauncher(spec: LaunchSpec): string {
+  // Forever-restart loop: wait for the bot process to exit, pause, relaunch.
+  // Prevents silent death when the node process crashes. GROK_TG_SUPERVISED=1
+  // tells the bot a supervisor will relaunch it (auto-update exits cleanly).
   const cmd = `""${spec.nodePath}"" ${spec.args.map((a) => `""${a}""`).join(" ")}`;
   return [
     'Set sh = CreateObject("WScript.Shell")',
     `sh.CurrentDirectory = "${spec.cwd}"`,
-    `sh.Run "${cmd}", 0, False`,
+    'Set env = sh.Environment("PROCESS")',
+    'env("GROK_TG_SUPERVISED") = "1"',
+    "Do",
+    `  sh.Run "${cmd}", 0, True`,
+    "  WScript.Sleep 3000",
+    "Loop",
   ].join("\r\n");
 }
 
 function killScript(entry: string): string {
   const safe = entry.replace(/'/g, "''");
+  // Kill the forever-restart VBS host *before* node, otherwise the 3s loop
+  // respawns the bot right after "stop". Targets our service / Startup launchers.
   return [
+    `$vbs = Get-CimInstance Win32_Process -Filter "Name='wscript.exe' OR Name='cscript.exe'" | Where-Object { $_.CommandLine -like '*GrokTelegramBot.vbs*' -or $_.CommandLine -like '*run-service.vbs*' };`,
+    `$vbs | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue };`,
     `$p = Get-CimInstance Win32_Process -Filter "Name='node.exe'" | Where-Object { $_.CommandLine -like '*${safe}*' };`,
     `$p | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue };`,
-    `"killed " + (@($p).Count)`,
+    `"killed " + (@($p).Count) + " node, " + (@($vbs).Count) + " vbs"`,
   ].join(" ");
 }
 

package/src/sessions/history.ts

@@ -5,6 +5,11 @@
 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 type { HistoryEntry, HistoryRole } from "./types.js";
 
 const TAIL_WINDOWS = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024]; // grow until entries found
@@ -46,6 +51,66 @@ 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);
+  if (entries.length === 0) return "";
+  // Walk newest → oldest for a useful assistant conclusion.
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]!;
+    if (e.role === "assistant" && e.text.trim()) {
+      const t = cleanCardProse(e.text);
+      if (t.length >= 20) return t;
+    }
+  }
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]!;
+    if (e.role === "user" && e.text.trim()) {
+      const t = cleanCardProse(e.text);
+      if (t && !/session import complete/i.test(t)) return t;
+    }
+  }
+  return "";
+}
+
+/**
+ * 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, "");
+  t = t.replace(/^TASK COMPLEXITY:[\s\S]*?User task:\s*/i, "");
+  if (/^Session status update \(meta only\)/i.test(t.trim())) return "";
+  t = t.replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  // Prefer the ending (conclusions).
+  if (t.length > max + 40) {
+    const tail = t.slice(-max + 1);
+    const sp = tail.indexOf(" ");
+    return "\u2026" + (sp > 0 && sp < 30 ? tail.slice(sp + 1) : tail);
+  }
+  return t.slice(0, max - 1) + "\u2026";
+}
+
 /** The first user prompt in a session log (read from the start), or "". */
 export function readFirstPrompt(jsonlPath: string, maxBytes = 256 * 1024): string {
   let size: number;
@@ -161,8 +226,41 @@ 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();
+  // 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)
+  ) {
+    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 = "";
   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/store.ts

@@ -17,6 +17,7 @@ interface RawSessionJson {
   created_at?: string;
   updated_at?: string;
   session_created_reason?: string;
+  comment?: string;
 }
 
 interface RawLock {
@@ -93,6 +94,7 @@ export class SessionStore {
       /* no history yet */
     }
 
+    const comment = (raw.comment || "").trim();
     return {
       sessionId,
       cwd: raw.cwd || "",
@@ -103,6 +105,7 @@ export class SessionStore {
       lockPid,
       active,
       historyBytes,
+      comment: comment || undefined,
     };
   }
 

package/src/sessions/types.ts

@@ -13,6 +13,11 @@ export interface SessionMeta {
   active: boolean;
   /** Size of the .jsonl history in bytes (proxy for conversation length). */
   historyBytes: number;
+  /**
+   * 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;
 }
 
 export type HistoryRole = "user" | "assistant" | "tool" | "system";

package/src/stream/streamer.ts

@@ -15,15 +15,20 @@ 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";
 
 const SOFT_LIMIT = 3500;
-const THINK_TAIL = 500;
+/** Display budget for a thinking block (middle-truncated; session context keeps all). */
+const THINK_DISPLAY_MAX = 2800;
 
 type SegKind = "out" | "think" | "tool";
 interface Seg {
   kind: SegKind;
   text: string;
+  /** When set, later tool updates replace this segment instead of appending. */
+  toolId?: string;
 }
 
 export class ResponseStreamer {
@@ -44,6 +49,11 @@ export class ResponseStreamer {
   private toolCalls = 0;
   private outChars = 0;
   private thoughtChars = 0;
+  /**
+   * Active plan board (ACP sessionUpdate "plan"). Always rendered just above
+   * the progress bar when set — done / in-progress / pending steps.
+   */
+  private planMarkdown: string | undefined;
 
   constructor(
     private readonly api: Api,
@@ -56,6 +66,8 @@ 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,
   ) {}
 
   /** Replace the hashtag footer (used after a logical fork swaps the session id
@@ -69,10 +81,11 @@ export class ResponseStreamer {
     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;
   }
@@ -112,12 +125,19 @@ export class ResponseStreamer {
     this.setProgressValue(100, false);
   }
 
+  private threadExtra(): Record<string, unknown> {
+    return this.messageThreadId !== undefined ? { message_thread_id: 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 {
@@ -134,6 +154,10 @@ export class ResponseStreamer {
     this.schedule();
   }
 
+  /**
+   * Append a one-shot tool card (no live updates). Prefer {@link upsertTool}
+   * for ACP tool calls that stream progress/output under a stable toolCallId.
+   */
   addTool(rawMarkdown: string): void {
     if (!rawMarkdown) return;
     this.toolCalls += 1;
@@ -141,6 +165,45 @@ export class ResponseStreamer {
     this.schedule();
   }
 
+  /**
+   * Insert or replace a tool card keyed by toolCallId so one command/edit stays
+   * a single Telegram block that auto-updates (no spam of new code sections).
+   * Full tool results remain in the agent session; this is display-only.
+   */
+  /** Replace the live plan board (or clear with empty/undefined). */
+  setPlan(markdown: string | undefined): void {
+    const next = markdown?.trim() ? markdown.trim() : undefined;
+    if (next === this.planMarkdown) return;
+    this.planMarkdown = next;
+    this.schedule();
+  }
+
+  upsertTool(toolId: string | undefined, rawMarkdown: string): void {
+    if (!rawMarkdown) return;
+    const id = (toolId || "").trim();
+    if (id) {
+      // Replace any existing segment with this id (newest first; includes rare
+      // sealed-region matches so we don't keep stale text in the segs model).
+      for (let i = this.segs.length - 1; i >= 0; i--) {
+        const s = this.segs[i]!;
+        if (s.kind === "tool" && s.toolId === id) {
+          if (s.text === rawMarkdown) return;
+          s.text = rawMarkdown;
+          // If the card lives only in a sealed bubble, also ensure a live copy
+          // so the user sees the latest output on the current message.
+          if (i < this.sealedIdx) {
+            this.segs.push({ kind: "tool", text: rawMarkdown, toolId: id });
+          }
+          this.schedule();
+          return;
+        }
+      }
+    }
+    this.toolCalls += 1;
+    this.segs.push({ kind: "tool", text: rawMarkdown, toolId: id || undefined });
+    this.schedule();
+  }
+
   get hasOutput(): boolean {
     return this.liveId !== undefined || this.segs.some((s) => s.text.trim().length > 0);
   }
@@ -182,13 +245,15 @@ export class ResponseStreamer {
       await this.sealOverflow();
       const base = this.captureProgress(renderSegs(this.segs.slice(this.sealedIdx)));
       this.applyFallback();
-      // Never send an empty / progress-only bubble. The bar is appended only to
-      // real streamed content; the live status panel shows the standalone bar.
-      if (!base.trim()) return;
-      // The live (still-streaming) bubble carries the hashtag footer AND a fresh
-      // progress bar at the bottom (sealed bubbles below get neither bar).
-      const parts: string[] = [base];
+      // Never send an empty / progress-only bubble. Plan alone is allowed so the
+      // board is visible as soon as the agent publishes steps.
+      if (!base.trim() && !this.planMarkdown) return;
+      // 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 (parts.length === 0) return;
       const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
       const rendered = toTelegramMarkdown(src);
       const chunks = chunkMarkdown(rendered);
@@ -255,7 +320,17 @@ function renderSegs(segs: Seg[]): string {
 function quoteThought(text: string): string {
   const t = text.trim();
   if (!t) return "";
-  const short = t.length > THINK_TAIL ? "…" + t.slice(-THINK_TAIL) : t;
+  // Keep both ends of long reasoning so early investigation is not lost in the UI.
+  // Truncation is display-only — the agent session retains every thought token.
+  // Neutralize fence markers and half-open emphasis so thinking never breaks
+  // MarkdownV2 parsing of the surrounding live message.
+  const safe = t
+    .replace(/```+/g, "'''")
+    .replace(/\*\*/g, "")
+    .replace(/__/g, "")
+    .replace(/~~/g, "");
+  const short = truncateMiddle(safe, THINK_DISPLAY_MAX);
   const lines = short.split("\n");
-  return lines.map((l, i) => (i === 0 ? `> 💭 *thinking:* ${l}` : `> ${l}`)).join("\n");
+  // Plain "thinking:" (no nested *bold*) — nested markers break mid-stream.
+  return lines.map((l, i) => (i === 0 ? `> \u{1F4AD} thinking: ${l}` : `> ${l}`)).join("\n");
 }

package/src/tasks/runner.ts

@@ -6,7 +6,7 @@
 import type { Api } from "grammy";
 import { basename } from "node:path";
 import type { GrokClient } from "../grok/client.js";
-import type { SessionUpdate } from "../grok/types.js";
+import { contentText, type SessionUpdate } from "../grok/types.js";
 import { createLogger } from "../logger.js";
 import { sendMarkdownDoc } from "../bot/telegram-io.js";
 import type { Task } from "./types.js";
@@ -29,8 +29,9 @@ export class TaskRunner {
 
     const listener = (sid: string, u: SessionUpdate): void => {
       if (sid !== sessionId) return;
-      if (u.sessionUpdate === "agent_message_chunk" && typeof u.content?.text === "string") {
-        text += u.content.text;
+      if (u.sessionUpdate === "agent_message_chunk") {
+        const t = contentText(u.content);
+        if (t) text += t;
       } else if (u.sessionUpdate === "tool_call") {
         const id = u.toolCallId || u.title || String(tools);
         if (!seen.has(id)) {