@inetafrica/open-claudia 2.2.15 → 2.2.17

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v2.2.17
+- Telegram output now uses `parse_mode: "HTML"` instead of legacy Markdown. The Telegram adapter normalizes both model-authored Telegram HTML and ordinary Markdown/CommonMark into Telegram's safe HTML subset before sending, so `<b>...</b>`, `**bold**`, backticks, links, headings, code blocks, strikethrough, and spoilers render cleanly instead of leaking literal markup or being rejected by Telegram. Messages still fall back to plain text if Telegram rejects the markup.
+- Updated the Telegram system prompt to ask agents for short mobile-readable Telegram HTML (`<b>`, `<code>`, `<pre>`, `<a>`) with bullet-style layout. Relay sends and slash-command responses now use the same HTML parse mode as normal assistant replies.
+
+## v2.2.16
+- New `/compactwindow` slash command (alias `/autocompact`) lets each user override the auto-compact token threshold from chat instead of editing `AUTO_COMPACT_TOKENS` in `.env` and restarting. Quick-pick buttons for 200k / 300k / 380k / 500k / Off / Default, or free-form `/compactwindow 250k` / `/compactwindow 0.5m` / `/compactwindow off` / `/compactwindow default`. Stored per-user as `settings.compactWindow` (persists across restarts via `state.json`); `null` falls back to the env default, `0` disables auto-compact entirely (manual `/compact` still works). `/status` now reports the effective window, and `/usage`'s "context is large" tip reflects the user's override.
+
 ## v2.2.15
 - Fix compaction loop: `compactActiveSession` no longer holds `isCompacting=true` for the full duration of its two-step flow. The flag now clears after step 1 (the summarizer) finishes, so step 2 (the seed-the-fresh-session call) runs as a regular long-running task. Previously, the seed step could pick up where the prior conversation left off and do real work — dev servers, package installs — for hours, all while the bot reported "Compacting context, will pick this up next…" to every incoming message. After a `/restart` the in-memory flag reset but `lastSessionId` still pointed to the same huge session, triggering an auto-compact on the next message and looping the same trap. New behaviour: the summarizer-only phase shows the compaction message; once the summary is written the bot returns to its normal "Queued." reply for any messages that arrive while the seed continuation runs.
 - Add `COMPACT_SUMMARY_TIMEOUT` (10 minutes) and thread it through `runClaudeCapture` via `opts.timeoutMs`. The summarizer is a single-shot summarisation call — if it hasn't returned in 10 minutes it's hung, not slow. Previously it could sit on the 6-hour `MAX_PROCESS_TIMEOUT` and lock the bot for a quarter of a day. The seed continuation keeps the full 6-hour budget since it can legitimately be a long-running agent task.

package/channels/telegram/adapter.js

@@ -10,6 +10,7 @@ const TelegramBot = require("node-telegram-bot-api");
 const { TEMP_DIR, FILES_DIR, CONFIG_DIR } = require("../../core/config");
 const { canonicalForChannel } = require("../../core/identity");
 const { portableToInlineKeyboard } = require("../types");
+const { telegramHtml } = require("./format");
 
 class TelegramAdapter {
   constructor({ id = "telegram", token, ownerChatId, chatIds }) {
@@ -204,6 +205,7 @@ class TelegramAdapter {
 
   async send(channelId, text, opts = {}) {
     const o = {};
+    const body = opts.parseMode === "HTML" ? telegramHtml(text) : text;
     if (opts.parseMode) o.parse_mode = opts.parseMode;
     const kb = this._normalizeKeyboard(opts.keyboard);
     if (kb) o.reply_markup = kb;
@@ -211,7 +213,7 @@ class TelegramAdapter {
 
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        const msg = await this.bot.sendMessage(channelId, text, o);
+        const msg = await this.bot.sendMessage(channelId, body, o);
         return msg.message_id;
       } catch (e) {
         const errMsg = e.message || "";
@@ -239,13 +241,14 @@ class TelegramAdapter {
   }
 
   async edit(channelId, messageId, text, opts = {}) {
+    const body = opts.parseMode === "HTML" ? telegramHtml(text) : text;
     const o = { chat_id: channelId, message_id: messageId };
     if (opts.parseMode) o.parse_mode = opts.parseMode;
     const kb = this._normalizeKeyboard(opts.keyboard);
     if (kb) o.reply_markup = kb;
 
     try {
-      await this.bot.editMessageText(text, o);
+      await this.bot.editMessageText(body, o);
     } catch (e) {
       const errMsg = e.message || "";
       if (errMsg.includes("retry after")) return;

package/channels/telegram/format.js

@@ -1,7 +1,18 @@
-// Telegram MarkdownV1 quirks: single-asterisk bold, single-underscore
-// italic, backticks for code. Most callers send `parseMode: "Markdown"`
-// strings already authored for Telegram, so this module is mostly a
-// pass-through with a couple of helpers.
+// Telegram formatting helpers.
+//
+// Telegram's legacy Markdown parser is too fragile for LLM output:
+// CommonMark `**bold**`, underscores in identifiers, unescaped dots in
+// MarkdownV2, and angle brackets in logs all commonly make Telegram reject
+// the message or render markup literally. The bot now sends Telegram HTML and
+// normalizes both model-authored Telegram HTML and ordinary Markdown into the
+// safe subset Telegram accepts.
+
+function escapeHtml(text) {
+  return String(text || "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
 
 function stripMarkdown(text) {
   return String(text || "")
@@ -9,4 +20,86 @@ function stripMarkdown(text) {
     .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
 }
 
-module.exports = { stripMarkdown };
+function stashCode(text) {
+  const blocks = [];
+  const stash = (html) => {
+    const token = `\u0000OCTGCODE${blocks.length}\u0000`;
+    blocks.push(html);
+    return token;
+  };
+
+  let out = String(text || "").replace(/```(?:[^\n`]*)\n?([\s\S]*?)```/g, (_, code) => {
+    return stash(`<pre>${escapeHtml(code.trimEnd())}</pre>`);
+  });
+
+  out = out.replace(/`([^`\n]+)`/g, (_, code) => {
+    return stash(`<code>${escapeHtml(code)}</code>`);
+  });
+
+  return { text: out, blocks };
+}
+
+function restoreAllowedHtmlTags(text) {
+  let out = text;
+
+  // Allow model-authored Telegram HTML tags after escaping the rest of the text.
+  for (const tag of ["b", "strong", "i", "em", "u", "s", "strike", "del", "code", "pre", "blockquote"]) {
+    const open = new RegExp(`&lt;${tag}&gt;`, "gi");
+    const close = new RegExp(`&lt;/${tag}&gt;`, "gi");
+    out = out.replace(open, `<${tag}>`).replace(close, `</${tag}>`);
+  }
+
+  // Telegram spoiler HTML.
+  out = out
+    .replace(/&lt;span class="tg-spoiler"&gt;/gi, '<span class="tg-spoiler">')
+    .replace(/&lt;\/span&gt;/gi, "</span>");
+
+  // Safe links only. Quotes are not escaped by escapeHtml(), but href content
+  // is still constrained to http(s)/mailto/tg schemes to avoid broken markup.
+  out = out.replace(/&lt;a href="([^"<>]+)"&gt;/gi, (_, href) => {
+    if (!/^(https?:|mailto:|tg:)/i.test(href)) return "";
+    return `<a href="${href}">`;
+  }).replace(/&lt;\/a&gt;/gi, "</a>");
+
+  return out;
+}
+
+function convertMarkdownToHtml(text) {
+  let out = text;
+
+  // Markdown links: [label](https://example.com)
+  out = out.replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, (_, label, url) => {
+    return `<a href="${url}">${label}</a>`;
+  });
+
+  // Headings become compact bold labels instead of literal # noise.
+  out = out.replace(/^\s{0,3}#{1,6}\s+(.+)$/gm, (_, title) => `<b>${title}</b>`);
+
+  // Bold. Handle CommonMark first, then Telegram Markdown v1 style.
+  out = out.replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "<b>$1</b>");
+  out = out.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, "<b>$1</b>");
+
+  // Italic. Keep conservative to avoid mangling snake_case identifiers.
+  out = out.replace(/(?<!_)_([^_\n]+)_(?!_)/g, "<i>$1</i>");
+
+  // Strikethrough and Telegram spoiler syntax.
+  out = out.replace(/~~([^~\n]+)~~/g, "<s>$1</s>");
+  out = out.replace(/\|\|([^|\n]+)\|\|/g, '<span class="tg-spoiler">$1</span>');
+
+  return out;
+}
+
+function telegramHtml(text) {
+  const { text: withoutCode, blocks } = stashCode(text);
+  let out = escapeHtml(withoutCode);
+  out = restoreAllowedHtmlTags(out);
+  out = convertMarkdownToHtml(out);
+
+  blocks.forEach((html, i) => {
+    out = out.replace(`\u0000OCTGCODE${i}\u0000`, html);
+  });
+
+  return out;
+}
+
+module.exports = { escapeHtml, stripMarkdown, telegramHtml };

package/core/actions.js

@@ -257,6 +257,19 @@ async function handleAction(envelope) {
   if (d.startsWith("m:")) { state.settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${state.settings.model || "default"}`); return; }
   if (d.startsWith("e:")) { const e = d.slice(2); state.settings.effort = e === "default" ? null : e; await send(`Effort: ${state.settings.effort || "default"}`); return; }
   if (d.startsWith("b:")) { const b = d.slice(2); state.settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${state.settings.budget ? "$" + state.settings.budget : "none"}`); return; }
+  if (d.startsWith("cw:")) {
+    const v = d.slice(3);
+    if (v === "default") state.settings.compactWindow = null;
+    else if (v === "off") state.settings.compactWindow = 0;
+    else {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n) && n > 0) state.settings.compactWindow = n;
+    }
+    saveState();
+    const { formatCompactWindow } = require("./handlers");
+    await send(`Auto-compact window: ${formatCompactWindow(state)}`);
+    return;
+  }
   if (d.startsWith("be:")) {
     const be = d.slice(3);
     if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }

package/core/handlers.js

@@ -24,7 +24,7 @@ const { runDoctorChecks, formatDoctorReport } = require("./doctor");
 const jobs = require("./jobs");
 const scheduler = require("./scheduler");
 const {
-  runClaude, compactActiveSession, getActiveSessionId,
+  runClaude, compactActiveSession, getActiveSessionId, effectiveCompactThreshold,
 } = require("./runner");
 const {
   getClaudeOAuthToken, claudeSubprocessEnv, saveClaudeOAuthToken,
@@ -119,7 +119,7 @@ register({
     if (!authorized(env)) return;
     send([
       "Session: /session /sessions /projects /continue /status /stop /end",
-      "Settings: /model /effort /budget /plan /compact /worktree /mode",
+      "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode",
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
       "Automation: /cron /vault /soul",
@@ -671,6 +671,58 @@ register({
   },
 });
 
+function parseCompactWindow(raw) {
+  const s = String(raw || "").trim().toLowerCase();
+  if (!s) return { value: undefined };
+  if (s === "default" || s === "auto" || s === "reset") return { value: null };
+  if (s === "off" || s === "disable" || s === "disabled") return { value: 0 };
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*([km]?)$/);
+  if (!m) return { error: `Couldn't parse "${raw}". Use a number like 250000, 250k, off, or default.` };
+  let n = parseFloat(m[1]);
+  if (m[2] === "k") n *= 1000;
+  else if (m[2] === "m") n *= 1000000;
+  n = Math.round(n);
+  if (n === 0) return { value: 0 };
+  if (n < 10000) return { error: "Compaction window must be at least 10k tokens (or use 'off' to disable)." };
+  return { value: n };
+}
+
+function formatCompactWindow(state) {
+  const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(0) + "k" : String(n);
+  const cw = state.settings?.compactWindow;
+  if (cw === 0) return "off";
+  if (cw == null) return `default (${fmt(AUTO_COMPACT_TOKENS)})`;
+  return fmt(cw);
+}
+
+register({
+  name: "compactwindow", aliases: ["autocompact"],
+  description: "Set auto-compact token threshold",
+  args: "[<tokens> | off | default]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    if (tail) {
+      const { value, error } = parseCompactWindow(tail);
+      if (error) return send(error);
+      state.settings.compactWindow = value;
+      saveState();
+      return send(`Auto-compact window: ${formatCompactWindow(state)}`);
+    }
+    send(
+      `Auto-compact window: ${formatCompactWindow(state)}\n\n` +
+      "When the last turn's input context exceeds this, the next reply triggers a compaction. " +
+      "Type /compactwindow <n> for a custom value (e.g. 250k).",
+      { keyboard: { inline_keyboard: [
+        [{ text: "200k", callback_data: "cw:200000" }, { text: "300k", callback_data: "cw:300000" }, { text: "380k", callback_data: "cw:380000" }, { text: "500k", callback_data: "cw:500000" }],
+        [{ text: "Off", callback_data: "cw:off" }, { text: "Default", callback_data: "cw:default" }],
+      ] } },
+    );
+  },
+});
+
+module.exports.formatCompactWindow = formatCompactWindow;
+
 register({
   name: "worktree", description: "Toggle isolated git branch",
   handler: async (env) => {
@@ -743,7 +795,7 @@ register({
   handler: async (env) => {
     if (!authorized(env)) return;
     await send("Bot mode: *direct* (default)\n\nSwitch to agent mode for non-blocking execution.\nIn agent mode, heavy tasks run in the background and you can keep chatting.", {
-      parseMode: "Markdown",
+      parseMode: "HTML",
       keyboard: { inline_keyboard: [[{ text: "Switch to Agent Mode", callback_data: "mode:agent" }]] },
     });
   },
@@ -787,6 +839,7 @@ register({
       `Project: ${state.currentSession.name}`,
       `Backend: ${backendLabel}`,
       `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
+      `Auto-compact: ${formatCompactWindow(state)}`,
       `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
       state.runningProcess ? "Working..." : "Ready.",
     ].join("\n"));
@@ -825,8 +878,15 @@ register({
       `Cost: $${u.costUsd.toFixed(4)}`,
       `Last turn context: ${fmt(u.lastInputTokens)}`,
     ];
-    if (u.lastInputTokens > 200000) lines.push(`\nTip: context is large. The bot auto-compacts after the next reply at ${fmt(AUTO_COMPACT_TOKENS)} tokens; /compact does it now.`);
-    send(lines.join("\n"), { parseMode: "Markdown" });
+    if (u.lastInputTokens > 200000) {
+      const threshold = effectiveCompactThreshold(currentState());
+      if (threshold === 0) {
+        lines.push(`\nTip: context is large. Auto-compact is off (/compactwindow); /compact does it now.`);
+      } else {
+        lines.push(`\nTip: context is large. The bot auto-compacts after the next reply at ${fmt(threshold)} tokens (/compactwindow); /compact does it now.`);
+      }
+    }
+    send(lines.join("\n"), { parseMode: "HTML" });
   },
 });
 

package/core/relay.js

@@ -35,7 +35,7 @@ async function send({ text, target, from = null, kind = "relay" }) {
   let messageId = null;
   let errorMsg = null;
   try {
-    const sendOpts = adapter.type === "telegram" ? { parseMode: "Markdown" } : {};
+    const sendOpts = adapter.type === "telegram" ? { parseMode: "HTML" } : {};
     const result = await adapter.send(resolved.channelId, String(text), sendOpts);
     if (typeof result === "object" && result && "messageId" in result) { messageId = result.messageId; ok = !!messageId; }
     else { messageId = result; ok = !!result; }

package/core/runner.js

@@ -22,9 +22,9 @@ const {
 const { getClaudeOAuthToken, claudeAuthRecoveryMessage, isClaudeAuthErrorText, claudeUsageLimitMessage, isClaudeUsageLimitText, runClaudeAuthStatusDiagnostic, claudeSubprocessEnv } = require("./auth-flow");
 const loopback = require("./loopback");
 
-function telegramMarkdownOpts(extra = {}) {
+function telegramHtmlOpts(extra = {}) {
   const adapter = currentAdapter();
-  return adapter?.type === "telegram" ? { ...extra, parseMode: "Markdown" } : extra;
+  return adapter?.type === "telegram" ? { ...extra, parseMode: "HTML" } : extra;
 }
 
 function chatEnvOverlay() {
@@ -87,10 +87,18 @@ function getActiveSessionKey(state = currentState()) {
   return "lastSessionId";
 }
 
+function effectiveCompactThreshold(state = currentState()) {
+  const override = state.settings?.compactWindow;
+  if (override === 0) return 0;
+  if (Number.isFinite(override) && override > 0) return override;
+  return Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000;
+}
+
 function shouldAutoCompact(state = currentState(), opts = {}) {
   if (opts.skipAutoCompact || opts.fresh || opts.continueSession || state.isCompacting) return false;
   if (!state[getActiveSessionKey(state)]) return false;
-  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000;
+  const threshold = effectiveCompactThreshold(state);
+  if (threshold === 0) return false;
   if ((state.sessionUsage?.lastInputTokens || 0) < threshold) return false;
   const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
   if (state.lastCompactedAt && (Date.now() - state.lastCompactedAt) < minInterval) return false;
@@ -468,9 +476,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       const display = formatProgress(assistantText, toolUses, currentTool, elapsed, currentToolDetail);
       if (display && display !== lastUpdate) {
         if (!state.statusMessageId && assistantText) {
-          state.statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, telegramMarkdownOpts({ replyTo: replyToMsgId }));
+          state.statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, telegramHtmlOpts({ replyTo: replyToMsgId }));
         } else if (state.statusMessageId) {
-          await editMessage(state.statusMessageId, display.length > 4000 ? display.slice(-4000) : display, telegramMarkdownOpts());
+          await editMessage(state.statusMessageId, display.length > 4000 ? display.slice(-4000) : display, telegramHtmlOpts());
         }
         lastUpdate = display;
       }
@@ -657,12 +665,12 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       const firstChunk = chunks[0];
 
       if (state.statusMessageId && chunks.length === 1) {
-        await editMessage(state.statusMessageId, firstChunk, telegramMarkdownOpts());
+        await editMessage(state.statusMessageId, firstChunk, telegramHtmlOpts());
       } else {
-        const sent = await send(firstChunk, telegramMarkdownOpts({ replyTo: replyToMsgId }));
+        const sent = await send(firstChunk, telegramHtmlOpts({ replyTo: replyToMsgId }));
         if (!sent) await send(firstChunk);
         for (let i = 1; i < chunks.length; i++) {
-          await send(chunks[i], telegramMarkdownOpts());
+          await send(chunks[i], telegramHtmlOpts());
         }
       }
       if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
@@ -757,6 +765,7 @@ module.exports = {
   getActiveBinary,
   getActiveSessionKey,
   shouldAutoCompact,
+  effectiveCompactThreshold,
   formatProgress,
   preflightClaudeAuthMessage,
   claudeEmptyFailureMessage,

package/core/state.js

@@ -43,7 +43,7 @@ const savedState = (() => {
 const userStates = new Map();
 
 function freshSettings() {
-  return { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude" };
+  return { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude", compactWindow: null };
 }
 
 function freshUsage() {

package/core/system-prompt.js

@@ -78,28 +78,28 @@ function buildSystemPrompt() {
 ## Telegram formatting
 Telegram is mobile-first and narrow. Optimize for readability in a small chat bubble.
 
-Use Telegram Markdown v1 only:
-- Bold labels with single asterisks: *Status:* / *Done:* / *Blocked:* / *Next:*
-- Italic with single underscores only when genuinely useful.
-- Inline code with backticks only for commands, file paths, IDs, short field names, and exact errors.
-- Fenced code blocks only for short commands or snippets. Do not paste long logs; save/send a file instead.
+Use Telegram HTML, not raw Markdown:
+- Bold labels with <b>Status:</b> / <b>Done:</b> / <b>Blocked:</b> / <b>Next:</b>
+- Italic with <i>...</i> only when genuinely useful.
+- Inline code with <code>...</code> only for commands, file paths, IDs, short field names, and exact errors.
+- Code blocks with <pre>...</pre> only for short commands or snippets. Do not paste long logs; save/send a file instead.
+- Links may use <a href="https://example.com">label</a>, or just paste the URL.
 
 Avoid formatting that renders badly or noisily in Telegram:
 - No Markdown tables.
 - No Markdown headings like #, ##, ###.
-- No CommonMark bold like **bold**; use *bold*.
-- No Markdown links like [text](url); use plain URLs when needed.
-- Do not wrap ordinary business words in backticks or quote marks. For example, write Payments completed, not \`Payments\` completed or 'Payments' completed.
+- No raw **bold** / *bold* as your preferred output, even though the bot has a fallback converter.
+- Do not wrap ordinary business words in backticks, <code>, or quote marks. For example, write Payments completed, not <code>Payments</code> completed or 'Payments' completed.
 - Avoid large paragraphs. Use short sections, blank lines, and 3-7 concise bullets.
 
 Good Telegram pattern:
-*Status:* CRM sync is still running cleanly.
+<b>Status:</b> CRM sync is still running cleanly.
 
-- Bills and Calls completed.
-- Leads completed with 20 rows.
-- Payments advanced to 2026-05-17 10:50.
+• Bills and Calls completed.
+• Leads completed with 20 rows.
+• Payments advanced to <code>2026-05-17 10:50</code>.
 
-*Issue:* JSON parse error after Retention. I’m checking that stream next.
+<b>Issue:</b> JSON parse error after Retention. I’m checking that stream next.
 `
     : adapter?.type === "kazee"
       ? `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.2.15",
+  "version": "2.2.17",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {