grok-telegram-bot 2.3.1 → 2.5.0

package/src/import/list-running.ts

@@ -0,0 +1,100 @@
+/**
+ * List the sessions a sibling telegram-bot currently treats as /running
+ * (controlledSessions in its data/settings.json), enriched with on-disk meta
+ * and first-prompt titles when available.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { createLogger } from "../logger.js";
+import { type ForeignSessionMeta, resolveForeignMeta } from "./history-readers.js";
+import type { ImportSource } from "./sources.js";
+
+const log = createLogger("import:list");
+
+export interface ImportableSession extends ForeignSessionMeta {
+  /** Source tool id (kiro / opencode / …). */
+  sourceId: string;
+  /** True when listed from that bot's controlledSessions (/running). */
+  fromRunning: boolean;
+}
+
+interface RawControlled {
+  sessionId?: string;
+  projectPath?: string;
+  projectName?: string;
+}
+
+interface RawChatSettings {
+  controlledSessions?: RawControlled[];
+  sessionId?: string;
+  projectPath?: string;
+  projectName?: string;
+  foregroundSessionId?: string;
+}
+
+/**
+ * Sessions currently controlled by the source bot (its /running list).
+ * When `chatId` is set, prefer that chat's controlled list; otherwise union
+ * every chat's controlled sessions (deduped by session id).
+ */
+export function listRunningFromSource(
+  src: ImportSource,
+  chatId?: number,
+): ImportableSession[] {
+  const controlled = readControlled(src, chatId);
+  const out: ImportableSession[] = [];
+  const seen = new Set<string>();
+
+  for (const c of controlled) {
+    if (!c.sessionId || seen.has(c.sessionId)) continue;
+    seen.add(c.sessionId);
+    const meta = resolveForeignMeta(src.format, src.sessionsRoot, c.sessionId, {
+      cwd: c.projectPath,
+      projectName: c.projectName || (c.projectPath ? basename(c.projectPath) : undefined),
+    });
+    if (!meta.cwd && c.projectPath) meta.cwd = c.projectPath;
+    if (!meta.projectName) {
+      meta.projectName = c.projectName || (meta.cwd ? basename(meta.cwd) : undefined);
+    }
+    out.push({ ...meta, sourceId: src.id, fromRunning: true });
+  }
+
+  return out;
+}
+
+function readControlled(src: ImportSource, chatId?: number): RawControlled[] {
+  if (!existsSync(src.settingsPath)) {
+    log.warn(`settings missing for ${src.id}: ${src.settingsPath}`);
+    return [];
+  }
+  let raw: Record<string, RawChatSettings>;
+  try {
+    raw = JSON.parse(readFileSync(src.settingsPath, "utf-8")) as Record<string, RawChatSettings>;
+  } catch (e) {
+    log.warn(`cannot parse settings for ${src.id}:`, (e as Error).message);
+    return [];
+  }
+
+  const collect = (s: RawChatSettings | undefined): RawControlled[] => {
+    if (!s) return [];
+    const list = [...(s.controlledSessions ?? [])];
+    // Also include the single-session fields if controlledSessions is empty.
+    if (list.length === 0 && s.sessionId) {
+      list.push({
+        sessionId: s.sessionId,
+        projectPath: s.projectPath,
+        projectName: s.projectName,
+      });
+    }
+    return list;
+  };
+
+  if (chatId !== undefined) {
+    const key = String(chatId);
+    if (raw[key]) return collect(raw[key]);
+  }
+
+  const all: RawControlled[] = [];
+  for (const s of Object.values(raw)) all.push(...collect(s));
+  return all;
+}

package/src/import/sources.ts

@@ -0,0 +1,78 @@
+/**
+ * Foreign session sources that can be imported into Grok: the four sibling
+ * Telegram bots on this machine. Each source has a bot root (for settings /
+ * /running controlled sessions) and a tool session store (history on disk).
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export type ImportSourceId = "kiro" | "opencode" | "claude" | "codex";
+
+/** How history is stored for a source tool. */
+export type HistoryFormat = "acp-jsonl" | "codex-rollout" | "opencode-storage";
+
+export interface ImportSource {
+  id: ImportSourceId;
+  /** Short label shown in the source picker. */
+  label: string;
+  /** Absolute path to the sibling telegram-bot project root. */
+  botRoot: string;
+  /** Path to that bot's settings.json (holds controlledSessions /running). */
+  settingsPath: string;
+  /**
+   * Tool session store root:
+   *  - acp-jsonl: dir of `<id>.json` + `<id>.jsonl`
+   *  - codex-rollout: `$CODEX_HOME/sessions` tree of rollouts
+   *  - opencode-storage: `~/.local/share/opencode` (storage/ under it)
+   */
+  sessionsRoot: string;
+  format: HistoryFormat;
+}
+
+const DOMAINS = "H:\\Lucru\\Domains";
+
+/** Built-in import sources (fixed paths as requested). */
+export const IMPORT_SOURCES: readonly ImportSource[] = [
+  {
+    id: "kiro",
+    label: "Kiro",
+    botRoot: join(DOMAINS, "kiro-telegram-bot"),
+    settingsPath: join(DOMAINS, "kiro-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".kiro", "sessions", "cli"),
+    format: "acp-jsonl",
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    botRoot: join(DOMAINS, "opencode-telegram-bot"),
+    settingsPath: join(DOMAINS, "opencode-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".local", "share", "opencode"),
+    format: "opencode-storage",
+  },
+  {
+    id: "claude",
+    label: "Claude",
+    botRoot: join(DOMAINS, "claude-telegram-bot"),
+    settingsPath: join(DOMAINS, "claude-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(DOMAINS, "claude-telegram-bot", "data", "sessions"),
+    format: "acp-jsonl",
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    botRoot: join(DOMAINS, "codex-telegram-bot"),
+    settingsPath: join(DOMAINS, "codex-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".codex", "sessions"),
+    format: "codex-rollout",
+  },
+] as const;
+
+export function getImportSource(id: string): ImportSource | undefined {
+  return IMPORT_SOURCES.find((s) => s.id === id);
+}
+
+/** True when the bot root exists on disk. */
+export function sourceAvailable(src: ImportSource): boolean {
+  return existsSync(src.botRoot);
+}

package/src/index.ts

@@ -2,29 +2,118 @@
  * Grok Telegram Bot — entry point.
  * Starts the Grok ACP bridge (`grok agent stdio`), the Telegram bot, and wires
  * graceful shutdown between them.
+ *
+ * Lifetime rules (critical):
+ *  - Prefer staying up over clean-but-dead exits.
+ *  - Uncaught errors are logged; the process keeps polling Telegram.
+ *  - grammY long-poll is restarted on transport/network death, 429, 409, etc.
+ *  - Never exit without a clear stderr + log line.
+ *  - Interactive `npm start` stays in-process (no silent detach re-exec).
+ *  - Supervised launches (GROK_TG_SUPERVISED=1) may exit for external relaunch.
  */
+import { join } from "node:path";
+import type { Bot } from "grammy";
+import { GrammyError, HttpError } from "grammy";
 import { GrokClient } from "./grok/client.js";
 import { createBot } from "./bot/bot.js";
 import { CANONICAL_DIR, loadConfig } from "./config.js";
 import { InstanceLock } from "./app/instance-lock.js";
-import { join } from "node:path";
+import {
+  isIntentionalShutdown,
+  markIntentionalShutdown,
+} from "./app/lifetime-flag.js";
 import { createLogger, enableFileLogging, setLogLevel } from "./logger.js";
 
+/** Last known reason for process end (read by exit/beforeExit handlers). */
+let exitReason = "unknown";
+/** Intentional exit in progress (SIGINT, fatal, lock, supervised relaunch). */
+let shuttingDown = false;
+/** beforeExit keep-alive armed at most once (avoid infinite 60s re-arm spam). */
+let beforeExitKeepalive: ReturnType<typeof setInterval> | undefined;
+/** Set immediately after config load; used by scream/shutdown. */
+let log!: ReturnType<typeof createLogger>;
+
+function noteExit(reason: string): void {
+  exitReason = reason;
+}
+
+function beginShutdown(reason: string): void {
+  shuttingDown = true;
+  markIntentionalShutdown(reason);
+  noteExit(reason);
+  if (beforeExitKeepalive) {
+    clearInterval(beforeExitKeepalive);
+    beforeExitKeepalive = undefined;
+  }
+}
+
+function scream(msg: string): void {
+  try {
+    process.stderr.write(`${msg}\n`);
+  } catch {
+    /* ignore */
+  }
+  try {
+    process.stdout.write(`${msg}\n`);
+  } catch {
+    /* ignore */
+  }
+  try {
+    log?.error(msg);
+  } catch {
+    /* ignore */
+  }
+}
+
 async function main(): Promise<void> {
   process.stdout.write("\u{1F916} Grok Telegram Bot — starting…\n");
 
   const cfg = loadConfig();
   setLogLevel(cfg.logLevel);
   enableFileLogging(cfg.logFile);
-  const log = createLogger("main");
+  log = createLogger("main");
+
+  // Always leave a trail — silent process death was the top reliability bug.
+  process.on("exit", (code) => {
+    const line = `[main] process exit code=${code} reason=${exitReason}`;
+    try {
+      // File logger may already be gone; still try console.
+      console.error(line);
+    } catch {
+      /* ignore */
+    }
+  });
+  process.on("beforeExit", (code) => {
+    // Never fight an intentional shutdown / fatal exit / updater re-exec.
+    if (shuttingDown || isIntentionalShutdown()) return;
+    if (beforeExitKeepalive) return; // already holding the process open
+    // Event loop emptied without an intentional shutdown — keep a handle alive
+    // so we don't vanish with code 0 and no explanation.
+    scream(
+      `\u26A0\uFE0F Event loop emptying (beforeExit code=${code}, reason=${exitReason}). ` +
+        `Keeping process alive — this usually means polling stopped unexpectedly.`,
+    );
+    noteExit(`beforeExit:${exitReason}`);
+    // One ref'd interval (not stacking setTimeouts that re-fire beforeExit forever).
+    beforeExitKeepalive = setInterval(() => {
+      if (shuttingDown || isIntentionalShutdown()) {
+        if (beforeExitKeepalive) clearInterval(beforeExitKeepalive);
+        return;
+      }
+      log?.warn(`beforeExit keepalive still holding process (reason=${exitReason})`);
+    }, 60_000);
+    beforeExitKeepalive.ref?.();
+  });
 
   // Single-instance guard: kill any ghost/duplicate already polling this token.
   const lock = new InstanceLock(cfg.token, join(CANONICAL_DIR, "locks"), process.env.GROK_TG_SUPERVISED === "1");
   if (cfg.singleInstance && !(await lock.acquire())) {
-    process.stdout.write(
-      "\u26D4 Another Grok Telegram Bot is already running for this token (a background service). Use `grok-tg restart`, or `grok-tg stop` first.\n",
-    );
-    process.exit(0);
+    const msg =
+      "Another Grok Telegram Bot is already running for this token (a background service). Use `grok-tg restart`, or `grok-tg stop` first.";
+    beginShutdown("instance-lock-held");
+    log.warn(msg);
+    scream(`\u26D4 ${msg}`);
+    process.exit(1);
   }
 
   log.info("starting Grok Telegram Bot");
@@ -33,6 +122,21 @@ async function main(): Promise<void> {
   log.info(`sessions:  ${cfg.sessionsDir}`);
   log.info(`log file:  ${cfg.logFile}`);
 
+  // Never die silently from stray exceptions — a dead bot is worse than a
+  // partially inconsistent one. Registering these handlers overrides Node's
+  // default "print and exit" for uncaughtException.
+  process.on("uncaughtException", (err) => {
+    noteExit(`uncaughtException:${err.message}`);
+    log.error("uncaughtException (process stays up):", err);
+    scream(`\u26A0\uFE0F uncaughtException (staying up): ${err.stack || err.message}`);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.stack || reason.message : String(reason);
+    noteExit(`unhandledRejection:${msg.slice(0, 120)}`);
+    log.error("unhandledRejection (process stays up):", reason instanceof Error ? reason : String(reason));
+    scream(`\u26A0\uFE0F unhandledRejection (staying up): ${msg}`);
+  });
+
   const grok = new GrokClient({
     grokCliPath: cfg.grokCliPath,
     workspace: cfg.workspace,
@@ -44,20 +148,65 @@ async function main(): Promise<void> {
     promptIdleTimeoutMs: cfg.promptIdleMs,
   });
 
-  await grok.start();
-  const { bot, registry, scheduler, updater } = await createBot(cfg, grok);
-  scheduler.start();
-  await updater.start();
+  // Retry ACP connect — agent crash at boot should not kill the Telegram bot.
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await grok.start();
+      break;
+    } catch (e) {
+      const wait = Math.min(60_000, 1000 * 2 ** Math.min(attempt, 5));
+      log.error(`Grok ACP start failed (attempt ${attempt}): ${(e as Error).message}; retry in ${wait}ms`);
+      scream(`\u26A0\uFE0F Grok ACP start failed (attempt ${attempt}): ${(e as Error).message}; retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  }
 
-  let shuttingDown = false;
-  const shutdown = (code: number): void => {
+  // createBot can fail on transient Telegram API issues — retry rather than die.
+  let bot: Bot;
+  let registry: Awaited<ReturnType<typeof createBot>>["registry"];
+  let scheduler: Awaited<ReturnType<typeof createBot>>["scheduler"];
+  let updater: Awaited<ReturnType<typeof createBot>>["updater"];
+  for (let attempt = 1; ; attempt++) {
+    try {
+      const bundle = await createBot(cfg, grok);
+      bot = bundle.bot;
+      registry = bundle.registry;
+      scheduler = bundle.scheduler;
+      updater = bundle.updater;
+      break;
+    } catch (e) {
+      const wait = Math.min(60_000, 1000 * 2 ** Math.min(attempt, 5));
+      const detail = formatTelegramError(e);
+      log.error(`createBot failed (attempt ${attempt}): ${detail}; retry in ${wait}ms`);
+      scream(`\u26A0\uFE0F createBot failed (attempt ${attempt}): ${detail}; retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  }
+
+  scheduler!.start();
+  await updater!.start();
+
+  const shutdown = (code: number, reason: string): void => {
     if (shuttingDown) return;
-    shuttingDown = true;
-    log.info("shutting down…");
-    scheduler.stop();
-    updater.stop();
-    registry.disposeAll();
-    void bot.stop().catch(() => {});
+    beginShutdown(reason);
+    log.info(`shutting down (code=${code}, reason=${reason})…`);
+    scream(`\u{1F6D1} Shutting down (code=${code}, reason=${reason})`);
+    try {
+      scheduler!.stop();
+    } catch {
+      /* ignore */
+    }
+    try {
+      updater!.stop();
+    } catch {
+      /* ignore */
+    }
+    try {
+      registry!.disposeAll();
+    } catch {
+      /* ignore */
+    }
+    void bot!.stop().catch(() => {});
     grok.stop();
     lock.release();
     setTimeout(() => process.exit(code), 500);
@@ -65,20 +214,156 @@ async function main(): Promise<void> {
 
   grok.on("restarted", () => log.info("Grok bridge re-bound; sessions continue on next message."));
 
-  process.on("SIGINT", () => shutdown(0));
-  process.on("SIGTERM", () => shutdown(0));
-  process.on("uncaughtException", (err) => log.error("uncaughtException:", err));
-  process.on("unhandledRejection", (err) => log.error("unhandledRejection:", err));
+  process.on("SIGINT", () => shutdown(0, "SIGINT"));
+  process.on("SIGTERM", () => shutdown(0, "SIGTERM"));
 
-  await bot.start({
-    onStart: (info) => {
-      log.info(`bot online as @${info.username}`);
-      process.stdout.write(`\u2705 Online as @${info.username}. Send it a message on Telegram.\n`);
-    },
-  });
+  // Keepalive + lock heartbeat — REF'd so the process cannot exit with an empty
+  // event loop while we still intend to run (unref was a silent-death footgun).
+  let botUsername = "?";
+  const keepalive = setInterval(() => {
+    try {
+      if (shuttingDown || isIntentionalShutdown()) return;
+      lock.touch();
+      log.info(
+        `keepalive: alive as @${botUsername} polling=${bot!.isRunning()} ` +
+          `pid=${process.pid} uptime=${Math.floor(process.uptime())}s`,
+      );
+    } catch (e) {
+      log.warn(`keepalive tick failed: ${(e as Error).message}`);
+    }
+  }, 5 * 60_000);
+  // Explicitly ref — do not unref.
+  keepalive.ref?.();
+
+  // Keep long-polling forever. On network / 409 / 429 / grammY fatal, wait and
+  // restart the poller in-process. Interactive runs never detach-relaunch
+  // (that looked like a silent death in the terminal).
+  while (!shuttingDown && !isIntentionalShutdown()) {
+    await runPollingForever(
+      bot!,
+      log,
+      () => shuttingDown || isIntentionalShutdown(),
+      (name) => {
+        botUsername = name;
+      },
+    );
+    if (shuttingDown || isIntentionalShutdown()) break;
+
+    // runPollingForever should only return when shuttingDown; if not, recover.
+    scream("\u26A0\uFE0F Telegram polling loop returned unexpectedly; recovering in-process");
+    log.error("Telegram polling loop returned unexpectedly; recovering in-process (no silent exit)");
+    noteExit("polling-loop-returned");
+
+    if (process.env.GROK_TG_SUPERVISED === "1") {
+      log.info("supervised mode — exiting for external relaunch");
+      noteExit("supervised-relaunch");
+      clearInterval(keepalive);
+      shutdown(1, "supervised-relaunch");
+      return;
+    }
+
+    // Stay in this process — re-enter polling after a short pause.
+    await sleep(3000);
+  }
+  clearInterval(keepalive);
+}
+
+/** grammY start with automatic recovery and loud classification of API errors. */
+async function runPollingForever(
+  bot: Bot,
+  log: ReturnType<typeof createLogger>,
+  isShuttingDown: () => boolean,
+  onOnline: (username: string) => void,
+): Promise<void> {
+  let attempt = 0;
+  while (!isShuttingDown()) {
+    try {
+      attempt = 0;
+      await bot.start({
+        onStart: (info) => {
+          onOnline(info.username);
+          log.info(`bot online as @${info.username}`);
+          process.stdout.write(`\u2705 Online as @${info.username}. Send it a message on Telegram.\n`);
+        },
+      });
+      // bot.start resolves when polling is stopped (bot.stop) or loop ends.
+      if (isShuttingDown()) return;
+      log.warn("bot.start resolved without shutdown; restarting polling in 2s");
+      scream("\u26A0\uFE0F bot.start resolved without shutdown; restarting polling in 2s");
+      await sleep(2000);
+    } catch (e) {
+      attempt++;
+      const classified = classifyPollingError(e);
+      const wait = classified.waitMs ?? Math.min(60_000, 2000 * 2 ** Math.min(attempt, 5));
+      const line =
+        `Telegram polling failed (attempt ${attempt}, ${classified.kind}): ${classified.message}; ` +
+        `retry in ${wait}ms`;
+      log.error(line);
+      scream(`\u26A0\uFE0F ${line}`);
+      try {
+        await bot.stop();
+      } catch {
+        /* ignore */
+      }
+      await sleep(wait);
+    }
+  }
+}
+
+function classifyPollingError(e: unknown): { kind: string; message: string; waitMs?: number } {
+  const message = formatTelegramError(e);
+  if (e instanceof GrammyError) {
+    if (e.error_code === 429) {
+      const ra = e.parameters?.retry_after;
+      const waitMs = typeof ra === "number" ? (ra + 1) * 1000 : 10_000;
+      return { kind: "429-rate-limit", message, waitMs };
+    }
+    if (e.error_code === 409) {
+      return {
+        kind: "409-conflict",
+        message: `${message} (another getUpdates consumer for this token?)`,
+        waitMs: 15_000,
+      };
+    }
+    if (e.error_code === 401) {
+      return {
+        kind: "401-unauthorized",
+        message: `${message} (check TELEGRAM_BOT_TOKEN)`,
+        waitMs: 60_000,
+      };
+    }
+    return { kind: `grammy-${e.error_code}`, message };
+  }
+  if (e instanceof HttpError) {
+    return { kind: "http-network", message, waitMs: 5_000 };
+  }
+  const msg = (e as Error)?.message ?? String(e);
+  if (/ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang|fetch failed|network/i.test(msg)) {
+    return { kind: "network", message: msg, waitMs: 5_000 };
+  }
+  return { kind: "unknown", message: msg };
+}
+
+function formatTelegramError(e: unknown): string {
+  if (e instanceof GrammyError) {
+    const ra = e.parameters?.retry_after;
+    const extra = typeof ra === "number" ? ` retry_after=${ra}s` : "";
+    return `${e.message} (code ${e.error_code}${extra})`;
+  }
+  if (e instanceof HttpError) return `HttpError: ${e.message}`;
+  if (e instanceof Error) return e.message;
+  return String(e);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
 }
 
 main().catch((err) => {
-  console.error("Fatal:", err instanceof Error ? err.message : err);
-  process.exit(1);
+  // Mark intentional exit so beforeExit keep-alive cannot swallow a real fatal.
+  beginShutdown(`fatal:${err instanceof Error ? err.message : String(err)}`);
+  const text = err instanceof Error ? err.stack || err.message : String(err);
+  console.error("Fatal:", text);
+  scream(`\u274C Fatal (exiting in 1s): ${text}`);
+  setTimeout(() => process.exit(1), 1000);
 });

package/src/projects/manager.ts

@@ -34,6 +34,13 @@ export class ProjectManager {
 
   /** List projects, de-duplicated by (case-insensitive) name. */
   list(limit = 100): ProjectEntry[] {
+    const out = this.listAll();
+    if (!Number.isFinite(limit) || limit <= 0 || limit >= out.length) return out;
+    return out.slice(0, limit);
+  }
+
+  /** Full catalog (no slice). Used by forum topic setup for 1000+ projects. */
+  listAll(): ProjectEntry[] {
     const byName = new Map<string, ProjectEntry>();
 
     for (const root of this.roots) {
@@ -62,17 +69,23 @@ export class ProjectManager {
 
     // Freshest first (directory mtime); callers may refine `lastUsed` with
     // session activity and re-sort. Alphabetical as a stable tiebreak.
-    const out = [...byName.values()].sort(
+    return [...byName.values()].sort(
       (a, b) => b.lastUsed - a.lastUsed || a.name.localeCompare(b.name),
     );
-    return out.slice(0, limit);
+  }
+
+  /** Exact catalog name match (case-insensitive). */
+  findExactByName(name: string): ProjectEntry | undefined {
+    const key = name.trim().toLowerCase();
+    if (!key) return undefined;
+    return this.listAll().find((p) => p.name.toLowerCase() === key);
   }
 
   /** Projects whose name contains the query (case-insensitive). */
   search(query: string, limit = 100): ProjectEntry[] {
     const q = query.trim().toLowerCase();
     if (!q) return this.list(limit);
-    return this.list(1000)
+    return this.listAll()
       .filter((p) => p.name.toLowerCase().includes(q))
       .slice(0, limit);
   }

package/src/render/chunk.ts

@@ -1,7 +1,7 @@
 /**
  * Split a MarkdownV2 string into Telegram-sized chunks (<= 4096 chars) without
- * breaking code fences. If a split happens inside a ``` block, the block is
- * closed before the boundary and reopened in the next chunk.
+ * breaking code fences. If a split happens inside a fenced block, the block is
+ * closed before the boundary and reopened in the next chunk (same tick length).
  */
 const LIMIT = 4000; // headroom under Telegram's 4096 hard limit
 
@@ -12,18 +12,19 @@ export function chunkMarkdown(text: string, limit = LIMIT): string[] {
   const chunks: string[] = [];
   let current: string[] = [];
   let size = 0;
-  let fenceLang: string | null = null; // non-null => currently inside a fence
+  /** Open fence: tick count + optional lang; null when outside a fence. */
+  let openFence: { ticks: number; lang: string } | null = null;
 
   const flush = (): void => {
     if (current.length === 0) return;
     let body = current.join("\n");
-    if (fenceLang !== null) body += "\n```"; // close dangling fence
+    if (openFence) body += "\n" + "`".repeat(openFence.ticks); // close dangling fence
     chunks.push(body);
     current = [];
     size = 0;
-    if (fenceLang !== null) {
-      // Reopen the fence at the top of the next chunk.
-      const reopen = "```" + fenceLang;
+    if (openFence) {
+      // Reopen the fence at the top of the next chunk (preserve tick length).
+      const reopen = "`".repeat(openFence.ticks) + openFence.lang;
       current.push(reopen);
       size = reopen.length + 1;
     }
@@ -31,9 +32,9 @@ export function chunkMarkdown(text: string, limit = LIMIT): string[] {
 
   for (const rawLine of lines) {
     const line = rawLine;
-    const fenceMatch = /^```(.*)$/.exec(line);
+    const fenceMatch = /^(```+)(.*)$/.exec(line);
 
-    // Hard-split a single oversized line.
+    // Hard-split a single oversized line (never mid-fence marker line).
     if (line.length + 1 > limit && fenceMatch === null) {
       flush();
       for (let i = 0; i < line.length; i += limit) {
@@ -48,7 +49,13 @@ export function chunkMarkdown(text: string, limit = LIMIT): string[] {
     size += line.length + 1;
 
     if (fenceMatch) {
-      fenceLang = fenceLang === null ? (fenceMatch[1] ?? "").trim() : null;
+      const ticks = fenceMatch[1]!.length;
+      const lang = (fenceMatch[2] ?? "").trim();
+      if (!openFence) {
+        openFence = { ticks, lang };
+      } else if (ticks >= openFence.ticks) {
+        openFence = null;
+      }
     }
   }