@iletai/nzb 1.3.5 → 1.4.0

package/dist/copilot/orchestrator.js

@@ -395,14 +395,14 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                     processQueue();
                 });
                 // Deliver response to user FIRST, then log best-effort
-                callback(finalContent, true);
                 try {
                     logMessage("out", sourceLabel, finalContent);
                 }
                 catch {
                     /* best-effort */
                 }
-                // Log both sides of the conversation after delivery
+                // Log both sides of the conversation before delivery so we have the row ID
+                let assistantLogId;
                 try {
                     const telegramMsgId = source.type === "telegram" ? source.messageId : undefined;
                     logConversation(logRole, prompt, sourceLabel, telegramMsgId);
@@ -411,11 +411,12 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                     /* best-effort */
                 }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel);
+                    assistantLogId = logConversation("assistant", finalContent, sourceLabel);
                 }
                 catch {
                     /* best-effort */
                 }
+                callback(finalContent, true, { assistantLogId });
                 // Auto-continue: if the response was cut short by timeout, automatically
                 // send a follow-up "Continue" message so the user doesn't have to
                 if (finalContent.includes("⏱ Response was cut short (timeout)")) {

package/dist/store/db.js

@@ -100,7 +100,6 @@ export function getDb() {
             removeMemory: db.prepare(`DELETE FROM memories WHERE id = ?`),
             memorySummary: db.prepare(`SELECT id, category, content FROM memories ORDER BY category, last_accessed DESC`),
             getConversationByMsgId: db.prepare(`SELECT id FROM conversation_log WHERE telegram_msg_id = ? LIMIT 1`),
-            getConversationAround: db.prepare(`SELECT role, content, source, ts FROM conversation_log WHERE id BETWEEN ? - 4 AND ? + 4 ORDER BY id ASC`),
         };
     }
     return db;
@@ -119,23 +118,35 @@ export function deleteState(key) {
     getDb(); // ensure init
     stmtCache.deleteState.run(key);
 }
-/** Log a conversation turn (user, assistant, or system) with optional Telegram message ID. */
+/** Log a conversation turn (user, assistant, or system) with optional Telegram message ID. Returns the row ID. */
 export function logConversation(role, content, source, telegramMsgId) {
     getDb(); // ensure init
-    stmtCache.logConversation.run(role, content, source, telegramMsgId ?? null);
+    const result = stmtCache.logConversation.run(role, content, source, telegramMsgId ?? null);
     // Keep last 200 entries to support context recovery after session loss
     logInsertCount++;
     if (logInsertCount % 50 === 0) {
         stmtCache.pruneConversation.run();
     }
+    return result.lastInsertRowid;
 }
-/** Get conversation context around a Telegram message ID (±2 turns). */
+/** Get conversation context around a Telegram message ID (±4 rows using proper subquery). */
 export function getConversationContext(telegramMsgId) {
-    getDb(); // ensure init
+    const db = getDb();
     const row = stmtCache.getConversationByMsgId.get(telegramMsgId);
     if (!row)
         return undefined;
-    const rows = stmtCache.getConversationAround.all(row.id, row.id);
+    // Fetch 4 rows before + the target + 4 rows after (handles ID gaps from pruning)
+    const rows = db.prepare(`
+		SELECT role, content, source, ts FROM (
+			SELECT * FROM conversation_log WHERE id < ? ORDER BY id DESC LIMIT 4
+		)
+		UNION ALL
+		SELECT role, content, source, ts FROM conversation_log WHERE id = ?
+		UNION ALL
+		SELECT role, content, source, ts FROM (
+			SELECT * FROM conversation_log WHERE id > ? ORDER BY id ASC LIMIT 4
+		)
+	`).all(row.id, row.id, row.id);
     if (rows.length === 0)
         return undefined;
     return rows
@@ -146,10 +157,10 @@ export function getConversationContext(telegramMsgId) {
     })
         .join("\n");
 }
-/** Update the most recent assistant log entry with its Telegram message ID (for reply-to lookups). */
-export function updateLastAssistantTelegramMsgId(telegramMsgId) {
+/** Set Telegram message ID on a specific conversation_log row (race-free). */
+export function setConversationTelegramMsgId(rowId, telegramMsgId) {
     const db = getDb();
-    db.prepare(`UPDATE conversation_log SET telegram_msg_id = ? WHERE id = (SELECT id FROM conversation_log WHERE role = 'assistant' ORDER BY id DESC LIMIT 1)`).run(telegramMsgId);
+    db.prepare(`UPDATE conversation_log SET telegram_msg_id = ? WHERE id = ?`).run(telegramMsgId, rowId);
 }
 /** Get recent conversation history formatted for injection into system message. */
 export function getRecentConversation(limit = 20) {

package/dist/telegram/bot.js

@@ -1,13 +1,13 @@
 import { autoRetry } from "@grammyjs/auto-retry";
 import { Menu } from "@grammyjs/menu";
-import { Bot, Keyboard } from "grammy";
+import { Bot, InlineKeyboard, Keyboard } from "grammy";
 import { Agent as HttpsAgent } from "https";
 import { config, persistEnvVar, persistModel } from "../config.js";
 import { cancelCurrentMessage, getQueueSize, getWorkers, sendToOrchestrator } from "../copilot/orchestrator.js";
 import { listSkills } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { searchMemories } from "../store/db.js";
-import { chunkMessage, formatToolSummaryExpandable, toTelegramMarkdown } from "./formatter.js";
+import { chunkMessage, escapeHtml, formatToolSummaryExpandable, toTelegramHTML } from "./formatter.js";
 import { initLogChannel, logDebug, logError, logInfo } from "./log-channel.js";
 let bot;
 const startedAt = Date.now();
@@ -125,9 +125,7 @@ function formatMemoryList(memories) {
     });
     return `🧠 <b>${memories.length} memories</b>\n\n${sections.join("\n\n")}`;
 }
-function escapeHtml(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
+// escapeHtml is imported from formatter.ts
 export function createBot() {
     if (!config.telegramBotToken) {
         throw new Error("Telegram bot token is missing. Run 'nzb setup' and enter the bot token from @BotFather.");
@@ -157,6 +155,56 @@ export function createBot() {
     });
     // Register interactive menu plugin
     bot.use(mainMenu);
+    // Callback handlers for contextual inline buttons
+    bot.callbackQuery("retry", async (ctx) => {
+        await ctx.answerCallbackQuery({ text: "Retrying..." });
+        const originalMsg = ctx.callbackQuery.message;
+        if (originalMsg?.reply_to_message && "text" in originalMsg.reply_to_message && originalMsg.reply_to_message.text) {
+            const retryPrompt = originalMsg.reply_to_message.text;
+            const chatId = ctx.chat.id;
+            sendToOrchestrator(retryPrompt, { type: "telegram", chatId, messageId: originalMsg.message_id }, (text, done) => {
+                if (done) {
+                    const formatted = toTelegramHTML(text);
+                    const chunks = chunkMessage(formatted);
+                    void (async () => {
+                        try {
+                            await bot.api.editMessageText(chatId, originalMsg.message_id, chunks[0], { parse_mode: "HTML" });
+                        }
+                        catch {
+                            try {
+                                await ctx.reply(text);
+                            }
+                            catch { }
+                        }
+                    })();
+                }
+            });
+        }
+    });
+    bot.callbackQuery("explain_error", async (ctx) => {
+        await ctx.answerCallbackQuery({ text: "Explaining..." });
+        const originalMsg = ctx.callbackQuery.message;
+        if (originalMsg && "text" in originalMsg && originalMsg.text) {
+            const chatId = ctx.chat.id;
+            sendToOrchestrator(`Explain this error in simple terms and suggest a fix:\n${originalMsg.text}`, { type: "telegram", chatId, messageId: originalMsg.message_id }, (text, done) => {
+                if (done) {
+                    const formatted = toTelegramHTML(text);
+                    const chunks = chunkMessage(formatted);
+                    void (async () => {
+                        try {
+                            await ctx.reply(chunks[0], { parse_mode: "HTML" });
+                        }
+                        catch {
+                            try {
+                                await ctx.reply(text);
+                            }
+                            catch { }
+                        }
+                    })();
+                }
+            });
+        }
+    });
     // Persistent reply keyboard — quick actions always visible below chat input
     const replyKeyboard = new Keyboard()
         .text("📊 Status").text("❌ Cancel").row()
@@ -402,8 +450,9 @@ export function createBot() {
                 void logDebug(`🔧 Tool start: ${event.toolName}${event.detail ? ` — ${event.detail}` : ""}`);
                 currentToolName = event.toolName;
                 toolHistory.push({ name: event.toolName, startTime: Date.now(), detail: event.detail });
+                const elapsed = ((Date.now() - handlerStartTime) / 1000).toFixed(1);
                 const existingText = lastEditedText.replace(/^🔧 .*\n\n/, "");
-                enqueueEdit(`🔧 ${event.toolName}\n\n${existingText}`.trim() || `🔧 ${event.toolName}`);
+                enqueueEdit(`🔧 ${event.toolName} (${elapsed}s...)\n\n${existingText}`.trim() || `🔧 ${event.toolName}`);
             }
             else if (event.type === "tool_complete") {
                 for (let i = toolHistory.length - 1; i >= 0; i--) {
@@ -412,14 +461,22 @@ export function createBot() {
                         break;
                     }
                 }
+                // Show completion with checkmark
+                const completedTool = toolHistory.find((t) => t.name === event.toolName && t.durationMs !== undefined);
+                if (completedTool) {
+                    const dur = (completedTool.durationMs / 1000).toFixed(1);
+                    const existingText = lastEditedText.replace(/^🔧 .*\n\n/, "").replace(/^✅ .*\n\n/, "");
+                    enqueueEdit(`✅ ${event.toolName} (${dur}s)\n\n${existingText}`.trim());
+                }
                 currentToolName = undefined;
             }
             else if (event.type === "tool_partial_result" && event.detail) {
                 const now = Date.now();
                 if (now - lastEditTime >= EDIT_INTERVAL_MS) {
                     lastEditTime = now;
+                    const elapsed = ((now - handlerStartTime) / 1000).toFixed(1);
                     const truncated = event.detail.length > 500 ? "⋯\n" + event.detail.slice(-500) : event.detail;
-                    const toolLine = `🔧 ${currentToolName || event.toolName}\n\`\`\`\n${truncated}\n\`\`\``;
+                    const toolLine = `🔧 ${currentToolName || event.toolName} (${elapsed}s...)\n<pre>${escapeHtml(truncated)}</pre>`;
                     enqueueEdit(toolLine);
                 }
             }
@@ -454,10 +511,11 @@ export function createBot() {
                 userPrompt = `[Replying to: "${quoted}"]\n\n${userPrompt}`;
             }
         }
-        sendToOrchestrator(userPrompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
+        sendToOrchestrator(userPrompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done, meta) => {
             if (done) {
                 finalized = true;
                 stopTyping();
+                const assistantLogId = meta?.assistantLogId;
                 const elapsed = ((Date.now() - handlerStartTime) / 1000).toFixed(1);
                 void logInfo(`✅ Response done (${elapsed}s, ${toolHistory.length} tools, ${text.length} chars)`);
                 // Wait for in-flight edits to finish before sending the final response
@@ -467,9 +525,10 @@ export function createBot() {
                     if (isError) {
                         void logError(`Response error: ${text.slice(0, 200)}`);
                         const errorText = `⚠️ ${text}`;
+                        const errorKb = new InlineKeyboard().text("🔄 Retry", "retry").text("📖 Explain", "explain_error");
                         if (placeholderMsgId) {
                             try {
-                                await bot.api.editMessageText(chatId, placeholderMsgId, errorText);
+                                await bot.api.editMessageText(chatId, placeholderMsgId, errorText, { reply_markup: errorKb });
                                 return;
                             }
                             catch {
@@ -477,7 +536,7 @@ export function createBot() {
                             }
                         }
                         try {
-                            await ctx.reply(errorText, { reply_parameters: replyParams });
+                            await ctx.reply(errorText, { reply_parameters: replyParams, reply_markup: errorKb });
                         }
                         catch {
                             /* nothing more we can do */
@@ -497,7 +556,7 @@ export function createBot() {
                             parts.push(`${(usageInfo.duration / 1000).toFixed(1)}s`);
                         textWithMeta += `\n\n📊 ${parts.join(" · ")}`;
                     }
-                    const formatted = toTelegramMarkdown(textWithMeta);
+                    const formatted = toTelegramHTML(textWithMeta);
                     let fullFormatted = formatted;
                     if (config.showReasoning && toolHistory.length > 0) {
                         const expandable = formatToolSummaryExpandable(toolHistory.map((t) => ({ name: t.name, durationMs: t.durationMs, detail: t.detail })));
@@ -508,16 +567,18 @@ export function createBot() {
                     // Single chunk: edit placeholder in place
                     if (placeholderMsgId && chunks.length === 1) {
                         try {
-                            await bot.api.editMessageText(chatId, placeholderMsgId, chunks[0], { parse_mode: "MarkdownV2" });
+                            await bot.api.editMessageText(chatId, placeholderMsgId, chunks[0], { parse_mode: "HTML" });
                             try {
                                 await bot.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
                             }
                             catch { }
-                            try {
-                                const { updateLastAssistantTelegramMsgId } = await import("../store/db.js");
-                                updateLastAssistantTelegramMsgId(placeholderMsgId);
+                            if (assistantLogId) {
+                                try {
+                                    const { setConversationTelegramMsgId } = await import("../store/db.js");
+                                    setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                }
+                                catch { }
                             }
-                            catch { }
                             return;
                         }
                         catch {
@@ -527,11 +588,13 @@ export function createBot() {
                                     await bot.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
                                 }
                                 catch { }
-                                try {
-                                    const { updateLastAssistantTelegramMsgId } = await import("../store/db.js");
-                                    updateLastAssistantTelegramMsgId(placeholderMsgId);
+                                if (assistantLogId) {
+                                    try {
+                                        const { setConversationTelegramMsgId } = await import("../store/db.js");
+                                        setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                    }
+                                    catch { }
                                 }
-                                catch { }
                                 return;
                             }
                             catch {
@@ -541,16 +604,19 @@ export function createBot() {
                     }
                     // Multi-chunk or edit fallthrough: send new chunks FIRST, then delete placeholder
                     const totalChunks = chunks.length;
+                    let firstSentMsgId;
                     const sendChunk = async (chunk, fallback, index) => {
                         const isFirst = index === 0 && !placeholderMsgId;
                         // Pagination header for multi-chunk messages
                         const pageTag = totalChunks > 1 ? `📄 ${index + 1}/${totalChunks}\n` : "";
                         const opts = isFirst
-                            ? { parse_mode: "MarkdownV2", reply_parameters: replyParams }
-                            : { parse_mode: "MarkdownV2" };
-                        await ctx
+                            ? { parse_mode: "HTML", reply_parameters: replyParams }
+                            : { parse_mode: "HTML" };
+                        const sent = await ctx
                             .reply(pageTag + chunk, opts)
                             .catch(() => ctx.reply(pageTag + fallback, isFirst ? { reply_parameters: replyParams } : {}));
+                        if (index === 0 && sent)
+                            firstSentMsgId = sent.message_id;
                     };
                     let sendSucceeded = false;
                     try {
@@ -567,7 +633,9 @@ export function createBot() {
                                 if (i > 0)
                                     await new Promise((r) => setTimeout(r, 300));
                                 const pageTag = fallbackChunks.length > 1 ? `📄 ${i + 1}/${fallbackChunks.length}\n` : "";
-                                await ctx.reply(pageTag + fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
+                                const sent = await ctx.reply(pageTag + fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
+                                if (i === 0 && sent)
+                                    firstSentMsgId = sent.message_id;
                             }
                             sendSucceeded = true;
                         }
@@ -584,6 +652,15 @@ export function createBot() {
                             /* ignore — placeholder stays but user has the real message */
                         }
                     }
+                    // Track bot message ID for reply-to context lookups
+                    const botMsgId = firstSentMsgId ?? placeholderMsgId;
+                    if (assistantLogId && botMsgId) {
+                        try {
+                            const { setConversationTelegramMsgId } = await import("../store/db.js");
+                            setConversationTelegramMsgId(assistantLogId, botMsgId);
+                        }
+                        catch { }
+                    }
                     // React ✅ on the user's original message to signal completion
                     try {
                         await bot.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
@@ -645,7 +722,7 @@ export function createBot() {
             const prompt = `[User sent a photo saved at: ${localPath}]\n\nCaption: ${caption}\n\nPlease analyze this image. The file is at ${localPath} — you can use bash to view it with tools if needed.`;
             sendToOrchestrator(prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
                 if (done) {
-                    const formatted = toTelegramMarkdown(text);
+                    const formatted = toTelegramHTML(text);
                     const chunks = chunkMessage(formatted);
                     const fallbackChunks = chunkMessage(text);
                     void (async () => {
@@ -655,7 +732,7 @@ export function createBot() {
                             const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
                             try {
                                 await ctx.api.sendMessage(chatId, pageTag + chunks[i], {
-                                    parse_mode: "MarkdownV2",
+                                    parse_mode: "HTML",
                                     reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
                                 });
                             }
@@ -717,7 +794,7 @@ export function createBot() {
             const prompt = `[User sent a file: ${doc.file_name || "unknown"} (${doc.file_size || 0} bytes), saved at: ${localPath}]\n\nCaption: ${caption}\n\nPlease analyze this file. You can read it with bash tools.`;
             sendToOrchestrator(prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
                 if (done) {
-                    const formatted = toTelegramMarkdown(text);
+                    const formatted = toTelegramHTML(text);
                     const chunks = chunkMessage(formatted);
                     const fallbackChunks = chunkMessage(text);
                     void (async () => {
@@ -727,7 +804,7 @@ export function createBot() {
                             const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
                             try {
                                 await ctx.api.sendMessage(chatId, pageTag + chunks[i], {
-                                    parse_mode: "MarkdownV2",
+                                    parse_mode: "HTML",
                                     reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
                                 });
                             }
@@ -769,6 +846,20 @@ export function createBot() {
             await ctx.reply("❌ Voice too long (max 5 min).", { reply_parameters: { message_id: userMessageId } });
             return;
         }
+        // If voice is a reply, include context
+        let voiceReplyContext = "";
+        const voiceReplyMsg = ctx.message.reply_to_message;
+        if (voiceReplyMsg && "text" in voiceReplyMsg && voiceReplyMsg.text) {
+            const { getConversationContext } = await import("../store/db.js");
+            const context = getConversationContext(voiceReplyMsg.message_id);
+            if (context) {
+                voiceReplyContext = `[Continuing from earlier conversation:]\n---\n${context}\n---\n\n`;
+            }
+            else {
+                const quoted = voiceReplyMsg.text.length > 500 ? voiceReplyMsg.text.slice(0, 500) + "…" : voiceReplyMsg.text;
+                voiceReplyContext = `[Replying to: "${quoted}"]\n\n`;
+            }
+        }
         try {
             const file = await ctx.api.getFile(ctx.message.voice.file_id);
             const filePath = file.file_path;
@@ -819,31 +910,44 @@ export function createBot() {
             else {
                 prompt = `[User sent a voice message (${duration}s), saved at: ${localPath}. No OPENAI_API_KEY configured for transcription. You can tell the user to set it up in ~/.nzb/.env]`;
             }
-            sendToOrchestrator(prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
+            sendToOrchestrator(voiceReplyContext + prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done, meta) => {
                 if (done) {
-                    const formatted = toTelegramMarkdown(text);
+                    const assistantLogId = meta?.assistantLogId;
+                    const formatted = toTelegramHTML(text);
                     const chunks = chunkMessage(formatted);
                     const fallbackChunks = chunkMessage(text);
                     void (async () => {
+                        let firstMsgId;
                         for (let i = 0; i < chunks.length; i++) {
                             if (i > 0)
                                 await new Promise((r) => setTimeout(r, 300));
                             const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
                             try {
-                                await ctx.api.sendMessage(chatId, pageTag + chunks[i], {
-                                    parse_mode: "MarkdownV2",
+                                const sent = await ctx.api.sendMessage(chatId, pageTag + chunks[i], {
+                                    parse_mode: "HTML",
                                     reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
                                 });
+                                if (i === 0)
+                                    firstMsgId = sent.message_id;
                             }
                             catch {
                                 try {
-                                    await ctx.api.sendMessage(chatId, pageTag + (fallbackChunks[i] ?? chunks[i]), {
+                                    const sent = await ctx.api.sendMessage(chatId, pageTag + (fallbackChunks[i] ?? chunks[i]), {
                                         reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
                                     });
+                                    if (i === 0)
+                                        firstMsgId = sent.message_id;
                                 }
                                 catch { }
                             }
                         }
+                        if (assistantLogId && firstMsgId) {
+                            try {
+                                const { setConversationTelegramMsgId } = await import("../store/db.js");
+                                setConversationTelegramMsgId(assistantLogId, firstMsgId);
+                            }
+                            catch { }
+                        }
                         try {
                             await ctx.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
                         }
@@ -911,7 +1015,7 @@ export async function stopBot() {
 export async function sendProactiveMessage(text) {
     if (!bot || config.authorizedUserId === undefined)
         return;
-    const formatted = toTelegramMarkdown(text);
+    const formatted = toTelegramHTML(text);
     const chunks = chunkMessage(formatted);
     const fallbackChunks = chunkMessage(text);
     for (let i = 0; i < chunks.length; i++) {
@@ -919,7 +1023,7 @@ export async function sendProactiveMessage(text) {
             await new Promise((r) => setTimeout(r, 300));
         const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
         try {
-            await bot.api.sendMessage(config.authorizedUserId, pageTag + chunks[i], { parse_mode: "MarkdownV2" });
+            await bot.api.sendMessage(config.authorizedUserId, pageTag + chunks[i], { parse_mode: "HTML" });
         }
         catch {
             try {

package/dist/telegram/formatter.js

@@ -1,10 +1,13 @@
 const TELEGRAM_MAX_LENGTH = 4096;
-// Reserve space for code block closure markers and pagination prefix
-const CHUNK_TARGET = TELEGRAM_MAX_LENGTH - 20;
+// Reserve space for tag closure and pagination prefix
+const CHUNK_TARGET = TELEGRAM_MAX_LENGTH - 40;
+/** Escape HTML special characters. */
+export function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 /**
  * Split a long message into chunks that fit within Telegram's message limit.
- * Code-block-aware: if a split falls inside a fenced code block, the block is
- * closed at the split and reopened in the next chunk so MarkdownV2 stays valid.
+ * HTML-aware: if a split falls inside a <pre> block, close and reopen it.
  */
 export function chunkMessage(text) {
     if (text.length <= TELEGRAM_MAX_LENGTH) {
@@ -25,12 +28,13 @@ export function chunkMessage(text) {
             splitAt = CHUNK_TARGET;
         }
         const segment = remaining.slice(0, splitAt);
-        // Count ``` markers — odd means we're splitting inside a code block
-        const markers = segment.match(/```/g);
-        const insideCodeBlock = markers !== null && markers.length % 2 !== 0;
+        // Count <pre> vs </pre> — mismatch means we're inside a code block
+        const opens = (segment.match(/<pre/g) || []).length;
+        const closes = (segment.match(/<\/pre>/g) || []).length;
+        const insideCodeBlock = opens > closes;
         if (insideCodeBlock) {
-            chunks.push(segment + "\n```");
-            remaining = "```\n" + remaining.slice(splitAt).trimStart();
+            chunks.push(segment + "\n</pre>");
+            remaining = "<pre>" + remaining.slice(splitAt).trimStart();
         }
         else {
             chunks.push(segment);
@@ -40,20 +44,7 @@ export function chunkMessage(text) {
     return chunks;
 }
 /**
- * Escape special characters for Telegram MarkdownV2 plain text segments.
- */
-export function escapeSegment(text) {
-    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
-}
-/**
- * Escape only characters needed inside a MarkdownV2 link URL.
- */
-function escapeLinkUrl(url) {
-    return url.replace(/([)\\])/g, "\\$1");
-}
-/**
- * Convert a markdown table into a readable mobile-friendly list.
- * Returns already-escaped MarkdownV2 text ready to be stashed.
+ * Convert a markdown table into a readable mobile-friendly HTML list.
  */
 function convertTable(table) {
     const rows = table
@@ -71,100 +62,84 @@ function convertTable(table) {
         .map((cols) => {
         if (cols.length === 0)
             return "";
-        const first = `*${escapeSegment(cols[0])}*`;
+        const first = `<b>${escapeHtml(cols[0])}</b>`;
         const rest = cols
             .slice(1)
-            .map((c) => escapeSegment(c))
+            .map((c) => escapeHtml(c))
             .join(" · ");
         return rest ? `${first} — ${rest}` : first;
     })
         .join("\n");
 }
 /**
- * Convert standard markdown from the AI into Telegram MarkdownV2.
+ * Convert standard markdown from the AI into Telegram HTML.
  * Handles bold, italic, strikethrough, links, lists, blockquotes,
  * code blocks, headers, tables, and horizontal rules.
  */
-export function toTelegramMarkdown(text) {
+export function toTelegramHTML(text) {
     const stash = [];
     const stashToken = (s) => {
         stash.push(s);
-        return `\x00STASH${stash.length - 1}\x00`;
+        return `\x00S${stash.length - 1}\x00`;
     };
     let out = text;
-    // 1. Stash fenced code blocks
-    out = out.replace(/```([a-z]*)\n?([\s\S]*?)```/g, (_m, lang, code) => stashToken("```" + (lang || "") + "\n" + code.trim() + "\n```"));
-    // 2. Stash inline code
-    out = out.replace(/`([^`\n]+)`/g, (_m, code) => stashToken("`" + code + "`"));
-    // 3. Stash markdown links — [text](url) → MarkdownV2 link
-    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, linkText, url) => stashToken(`[${escapeSegment(linkText)}](${escapeLinkUrl(url)})`));
-    // 4. Convert tables — stash to avoid double-escaping
+    // 1. Stash fenced code blocks → <pre><code>
+    out = out.replace(/```([a-z]*)\n?([\s\S]*?)```/g, (_m, lang, code) => {
+        const cls = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+        return stashToken(`<pre><code${cls}>${escapeHtml(code.trim())}</code></pre>`);
+    });
+    // 2. Stash inline code → <code>
+    out = out.replace(/`([^`\n]+)`/g, (_m, code) => stashToken(`<code>${escapeHtml(code)}</code>`));
+    // 3. Stash markdown links → <a href>
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, linkText, url) => stashToken(`<a href="${escapeHtml(url)}">${escapeHtml(linkText)}</a>`));
+    // 4. Convert tables
     out = out.replace(/(?:^\|.+\|[ \t]*$\n?)+/gm, (table) => stashToken(convertTable(table) + "\n"));
     // 5. Convert headers → bold
     out = out.replace(/^#{1,6}\s+(.+)$/gm, (_m, title) => `**${title.trim()}**`);
     // 6. Remove horizontal rules
     out = out.replace(/^[-*_]{3,}\s*$/gm, "");
-    // 7. Convert blockquotes: > text → MarkdownV2 blockquote (stash > to avoid escaping)
-    out = out.replace(/^>\s?(.*)$/gm, (_m, content) => stashToken(">") + content);
-    // 8. Convert unordered lists: - item or * item → • item
-    out = out.replace(/^(\s*)[-*]\s+/gm, "$1• ");
-    // 9. Convert ordered lists: 1. item → 1\) item (stash \) to avoid double-escaping)
-    out = out.replace(/^(\s*)(\d+)\.\s+/gm, (_m, spaces, num) => spaces + num + stashToken("\\) "));
-    // 10. Extract strikethrough before escaping
-    const strikeParts = [];
-    out = out.replace(/~~(.+?)~~/g, (_m, inner) => {
-        strikeParts.push(inner);
-        return `\x00STRIKE${strikeParts.length - 1}\x00`;
-    });
-    // 11. Extract bold markers before escaping
-    const boldParts = [];
-    out = out.replace(/\*\*(.+?)\*\*/g, (_m, inner) => {
-        boldParts.push(inner);
-        return `\x00BOLD${boldParts.length - 1}\x00`;
+    // 7. Blockquotes → <blockquote>
+    out = out.replace(/(?:^>\s?(.*)$\n?)+/gm, (block) => {
+        const content = block.replace(/^>\s?/gm, "").trim();
+        return stashToken(`<blockquote>${escapeHtml(content)}</blockquote>`);
     });
-    // 12. Extract italic markers before escaping
-    const italicParts = [];
-    out = out.replace(/\*(.+?)\*/g, (_m, inner) => {
-        italicParts.push(inner);
-        return `\x00ITALIC${italicParts.length - 1}\x00`;
-    });
-    // 13. Extract underline markers before escaping
-    const underlineParts = [];
-    out = out.replace(/__(.+?)__/g, (_m, inner) => {
-        underlineParts.push(inner);
-        return `\x00UNDERLINE${underlineParts.length - 1}\x00`;
-    });
-    // 14. Escape everything that remains
-    out = escapeSegment(out);
-    // 15. Restore formatting with escaped inner text
-    out = out.replace(/\x00STRIKE(\d+)\x00/g, (_m, i) => `~${escapeSegment(strikeParts[+i])}~`);
-    out = out.replace(/\x00BOLD(\d+)\x00/g, (_m, i) => `*${escapeSegment(boldParts[+i])}*`);
-    out = out.replace(/\x00ITALIC(\d+)\x00/g, (_m, i) => `_${escapeSegment(italicParts[+i])}_`);
-    out = out.replace(/\x00UNDERLINE(\d+)\x00/g, (_m, i) => `__${escapeSegment(underlineParts[+i])}__`);
-    // 16. Restore stashed code blocks, inline code, links, tables
-    out = out.replace(/\x00STASH(\d+)\x00/g, (_m, i) => stash[+i]);
+    // 8. Unordered lists: - item or * item → • item
+    out = out.replace(/^(\s*)[-*]\s+/gm, "$1• ");
+    // 9. Ordered lists: keep as-is (1. 2. 3.)
+    // 10. Strikethrough ~~text~~ → <s>
+    out = out.replace(/~~(.+?)~~/g, (_m, inner) => stashToken(`<s>\x00ESC${inner}\x00ESC</s>`));
+    // 11. Bold **text** → <b>
+    out = out.replace(/\*\*(.+?)\*\*/g, (_m, inner) => stashToken(`<b>\x00ESC${inner}\x00ESC</b>`));
+    // 12. Italic *text* → <i>
+    out = out.replace(/\*(.+?)\*/g, (_m, inner) => stashToken(`<i>\x00ESC${inner}\x00ESC</i>`));
+    // 13. Underline __text__ → <u>
+    out = out.replace(/__(.+?)__/g, (_m, inner) => stashToken(`<u>\x00ESC${inner}\x00ESC</u>`));
+    // 14. Escape remaining plain text
+    out = escapeHtml(out);
+    // 15. Restore stashed tokens
+    out = out.replace(/\x00S(\d+)\x00/g, (_m, i) => stash[+i]);
+    // 16. Escape inner text of formatting tags (marked with ESC)
+    out = out.replace(/\x00ESC([\s\S]*?)\x00ESC/g, (_m, inner) => escapeHtml(inner));
     // 17. Clean up excessive blank lines
     out = out.replace(/\n{3,}/g, "\n\n");
     return out.trim();
 }
+/** @deprecated Use toTelegramHTML instead. Kept for backward compatibility. */
+export const toTelegramMarkdown = toTelegramHTML;
+export const escapeSegment = escapeHtml;
 /**
- * Format tool call info as a Telegram MarkdownV2 expandable blockquote.
- * First line (title) is always visible, tool list expands on tap.
+ * Format tool call info as Telegram HTML expandable blockquote.
+ * First line visible, tool list expands on tap.
  */
 export function formatToolSummaryExpandable(toolCalls) {
     if (toolCalls.length === 0)
         return "";
     const lines = toolCalls.map((t) => {
-        const name = escapeSegment(t.name);
-        const dur = t.durationMs !== undefined
-            ? ` \\(${escapeSegment((t.durationMs / 1000).toFixed(1) + "s")}\\)`
-            : "";
-        const detail = t.detail ? `\n>  _${escapeSegment(t.detail.slice(0, 60))}_` : "";
-        return `${escapeSegment("• ")}${name}${dur}${detail}`;
+        const name = escapeHtml(t.name);
+        const dur = t.durationMs !== undefined ? ` (${(t.durationMs / 1000).toFixed(1)}s)` : "";
+        const detail = t.detail ? `\n  <i>${escapeHtml(t.detail.slice(0, 60))}</i>` : "";
+        return `• ${name}${dur}${detail}`;
     });
-    const header = escapeSegment("🔧 Tools used:");
-    const toolList = lines.join(`\n>`);
-    // Expandable: header visible, tool list hidden until tapped
-    return `\n\n**>${header}\n>${toolList}||`;
+    return `\n\n<blockquote expandable>🔧 Tools used:\n${lines.join("\n")}</blockquote>`;
 }
 //# sourceMappingURL=formatter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@iletai/nzb",
-	"version": "1.3.5",
+	"version": "1.4.0",
 	"description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
 	"bin": {
 		"nzb": "dist/cli.js"