@foxden-app/foxclaw 0.5.39 → 0.5.41

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.5.41 - 2026-06-18
+
+### 中文
+- 将 FoxClaw 的普通 Telegram 回复统一升级为 RichMessage Markdown 优先发送，覆盖短提示、usage、操作结果、升级开始/完成、错误通知和大多数诊断文本。
+- 保持稳定降级：Telegram rich markdown 失败时自动回普通文本；`/status`、`/auth`、`/update` 阻塞诊断等结构化面板继续使用已验证的 RichMessage HTML 表格/列表/details。
+
+### English
+- Upgraded FoxClaw's normal Telegram replies to prefer RichMessage Markdown, covering short notices, usage text, action results, update start/completion messages, error notifications, and most diagnostic text.
+- Stable fallback is preserved: Telegram rich markdown failures automatically return to plain text, while structured panels such as `/status`, `/auth`, and blocked `/update` diagnostics continue using the verified RichMessage HTML tables/lists/details path.
+
+## 0.5.40 - 2026-06-18
+
+### 中文
+- Codex 普通输出完成后优先使用 Telegram 原生 RichMessage Markdown 发送/编辑，保留原始 Markdown 给 Telegram 解析，用于观察编号列表、复制文本和更多 Markdown 语法的真实客户端表现。
+- 如果 Telegram 拒绝原生 Rich Markdown，FoxClaw 会自动退回现有 Markdown -> Rich HTML 转换；若 rich 编辑仍失败，则保留已经发送的普通文本，避免影响输出稳定性。Rich draft 也采用同样的 markdown 优先、HTML/纯文本降级路径。
+
+### English
+- Normal Codex output now prefers Telegram's native RichMessage Markdown when finalizing sent segments, preserving the original Markdown for Telegram to parse so ordered lists, copied text, and broader Markdown syntax can be observed in real clients.
+- If Telegram rejects native Rich Markdown, FoxClaw automatically falls back to the existing Markdown-to-Rich-HTML renderer; if rich editing still fails, the already-sent plain text remains intact. Rich drafts use the same markdown-first path with HTML/plain fallback.
+
 ## 0.5.39 - 2026-06-17
 
 ### 中文

package/dist/channels/bridge_messaging_router.d.ts

@@ -16,14 +16,17 @@ export declare class BridgeMessagingRouter {
     sendPlain(scopeId: string, text: string, keyboard?: InlineKeyboard): Promise<number>;
     sendHtml(scopeId: string, text: string, keyboard?: InlineKeyboard): Promise<number>;
     sendRichHtml(scopeId: string, html: string, fallbackHtml: string, keyboard?: InlineKeyboard): Promise<number>;
+    sendRichMarkdown(scopeId: string, markdown: string, fallbackText: string, keyboard?: InlineKeyboard): Promise<number>;
     editPlain(scopeId: string, messageId: number, text: string, keyboard?: InlineKeyboard): Promise<void>;
     editHtml(scopeId: string, messageId: number, text: string, keyboard?: InlineKeyboard): Promise<void>;
     editRichHtml(scopeId: string, messageId: number, html: string, fallbackHtml: string, keyboard?: InlineKeyboard): Promise<void>;
+    editRichMarkdown(scopeId: string, messageId: number, markdown: string, fallbackText: string, keyboard?: InlineKeyboard): Promise<void>;
     deleteMessage(scopeId: string, messageId: number): Promise<void>;
     sendTypingInScope(scopeId: string): Promise<void>;
     clearInlineKeyboard(scopeId: string, messageId: number): Promise<void>;
     sendDraft(scopeId: string, draftId: number, text: string): Promise<void>;
     sendRichDraft(scopeId: string, draftId: number, html: string, fallbackText: string): Promise<void>;
+    sendRichMarkdownDraft(scopeId: string, draftId: number, markdown: string, fallbackText: string): Promise<void>;
     answerCallback(callbackQueryId: string, text: string): Promise<void>;
     getFile(fileId: string): Promise<TelegramRemoteFile>;
     downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;

package/dist/channels/bridge_messaging_router.js

@@ -43,6 +43,12 @@ export class BridgeMessagingRouter {
         }
         return this.telegram.sendRichHtml(scopeId, html, keyboard);
     }
+    sendRichMarkdown(scopeId, markdown, fallbackText, keyboard) {
+        if (this.isWeixinScope(scopeId)) {
+            return this.requireWeixinTransport(scopeId).sendPlain(scopeId, fallbackText, keyboard);
+        }
+        return this.telegram.sendRichMarkdown(scopeId, markdown, keyboard);
+    }
     editPlain(scopeId, messageId, text, keyboard) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).editPlain(scopeId, messageId, text, keyboard);
@@ -61,6 +67,12 @@ export class BridgeMessagingRouter {
         }
         return this.telegram.editRichHtml(scopeId, messageId, html, keyboard);
     }
+    editRichMarkdown(scopeId, messageId, markdown, fallbackText, keyboard) {
+        if (this.isWeixinScope(scopeId)) {
+            return this.requireWeixinTransport(scopeId).editPlain(scopeId, messageId, fallbackText, keyboard);
+        }
+        return this.telegram.editRichMarkdown(scopeId, messageId, markdown, keyboard);
+    }
     deleteMessage(scopeId, messageId) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).deleteMessage(scopeId, messageId);
@@ -91,6 +103,12 @@ export class BridgeMessagingRouter {
         }
         return this.telegram.sendRichDraft(scopeId, draftId, html);
     }
+    sendRichMarkdownDraft(scopeId, draftId, markdown, fallbackText) {
+        if (this.isWeixinScope(scopeId)) {
+            return this.requireWeixinTransport(scopeId).sendDraft(scopeId, draftId, fallbackText);
+        }
+        return this.telegram.sendRichMarkdownDraft(scopeId, draftId, markdown);
+    }
     answerCallback(callbackQueryId, text) {
         return this.telegram.answerCallback(callbackQueryId, text);
     }

package/dist/channels/telegram/telegram_messaging_port.d.ts

@@ -14,14 +14,17 @@ export declare class TelegramMessagingPort implements ChannelPort {
     sendPlain(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
     sendHtml(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
     sendRichHtml(bridgeScopeId: string, html: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
+    sendRichMarkdown(bridgeScopeId: string, markdown: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
     editPlain(bridgeScopeId: string, messageId: number, text: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
     editHtml(bridgeScopeId: string, messageId: number, text: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
     editRichHtml(bridgeScopeId: string, messageId: number, html: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
+    editRichMarkdown(bridgeScopeId: string, messageId: number, markdown: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
     deleteMessage(bridgeScopeId: string, messageId: number): Promise<void>;
     sendTypingInScope(bridgeScopeId: string): Promise<void>;
     clearInlineKeyboard(bridgeScopeId: string, messageId: number): Promise<void>;
     sendDraft(bridgeScopeId: string, draftId: number, text: string): Promise<void>;
     sendRichDraft(bridgeScopeId: string, draftId: number, html: string): Promise<void>;
+    sendRichMarkdownDraft(bridgeScopeId: string, draftId: number, markdown: string): Promise<void>;
     answerCallback(callbackQueryId: string, text: string): Promise<void>;
     getFile(fileId: string): Promise<TelegramRemoteFile>;
     downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;

package/dist/channels/telegram/telegram_messaging_port.js

@@ -1,5 +1,5 @@
 import { parseTelegramTargetFromBridgeScope } from '../../core/bridge_scope.js';
-import { telegramRichHtml } from '../../telegram/rich.js';
+import { telegramRichHtml, telegramRichMarkdown } from '../../telegram/rich.js';
 /**
  * Telegram outbound operations addressed by bridge scope id (`telegram:…`).
  */
@@ -20,6 +20,10 @@ export class TelegramMessagingPort {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         return this.gateway.sendRichMessage(target.chatId, telegramRichHtml(html, { skipEntityDetection: true }), inlineKeyboard, target.topicId);
     }
+    async sendRichMarkdown(bridgeScopeId, markdown, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        return this.gateway.sendRichMessage(target.chatId, telegramRichMarkdown(markdown, { skipEntityDetection: true }), inlineKeyboard, target.topicId);
+    }
     async editPlain(bridgeScopeId, messageId, text, inlineKeyboard) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         await this.gateway.editMessage(target.chatId, messageId, text, inlineKeyboard);
@@ -32,6 +36,10 @@ export class TelegramMessagingPort {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         await this.gateway.editRichMessage(target.chatId, messageId, telegramRichHtml(html, { skipEntityDetection: true }), inlineKeyboard);
     }
+    async editRichMarkdown(bridgeScopeId, messageId, markdown, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.editRichMessage(target.chatId, messageId, telegramRichMarkdown(markdown, { skipEntityDetection: true }), inlineKeyboard);
+    }
     async deleteMessage(bridgeScopeId, messageId) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         await this.gateway.deleteMessage(target.chatId, messageId);
@@ -52,6 +60,10 @@ export class TelegramMessagingPort {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         await this.gateway.sendRichMessageDraft(target.chatId, draftId, telegramRichHtml(html, { skipEntityDetection: true }), target.topicId);
     }
+    async sendRichMarkdownDraft(bridgeScopeId, draftId, markdown) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.sendRichMessageDraft(target.chatId, draftId, telegramRichMarkdown(markdown, { skipEntityDetection: true }), target.topicId);
+    }
     answerCallback(callbackQueryId, text) {
         return this.gateway.answerCallback(callbackQueryId, text);
     }

package/dist/controller/controller.d.ts

@@ -445,6 +445,7 @@ export declare class BridgeSessionCore {
     private clearMessageButtons;
     private sendDraft;
     private sendRichDraft;
+    private sendRichMarkdownDraft;
     private renderActiveStatus;
     private dismissTurnPreview;
     private ensureStatusMessage;

package/dist/controller/controller.js

@@ -3361,7 +3361,7 @@ export class BridgeSessionCore {
         writeRuntimeStatus(this.config.statusPath, status);
     }
     async sendMessage(scopeId, text, inlineKeyboard) {
-        return this.messaging.sendPlain(scopeId, text, inlineKeyboard);
+        return this.sendRichMarkdownMessage(scopeId, text, inlineKeyboard);
     }
     async sendHtmlMessage(scopeId, text, inlineKeyboard) {
         return this.messaging.sendHtml(scopeId, text, inlineKeyboard);
@@ -3376,7 +3376,13 @@ export class BridgeSessionCore {
         }
     }
     async sendRichMarkdownMessage(scopeId, text, inlineKeyboard) {
-        return this.sendRichHtmlMessage(scopeId, renderTelegramMarkdownRichHtml(text), escapeTelegramHtml(text), inlineKeyboard);
+        try {
+            return await this.messaging.sendRichMarkdown(scopeId, text, text, inlineKeyboard);
+        }
+        catch (markdownError) {
+            this.logger.warn('telegram.rich_markdown_send_failed', { scopeId, error: toErrorMeta(markdownError) });
+            return this.sendRichHtmlMessage(scopeId, renderTelegramMarkdownRichHtml(text), escapeTelegramHtml(text), inlineKeyboard);
+        }
     }
     async sendRichInternalMessage(scopeId, title, text, inlineKeyboard) {
         if (scopeId.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX)) {
@@ -7772,6 +7778,15 @@ export class BridgeSessionCore {
     async sendRichDraft(scopeId, draftId, html, fallbackText) {
         await this.messaging.sendRichDraft(scopeId, draftId, html, fallbackText);
     }
+    async sendRichMarkdownDraft(scopeId, draftId, markdown, fallbackText) {
+        try {
+            await this.messaging.sendRichMarkdownDraft(scopeId, draftId, markdown, fallbackText);
+        }
+        catch (markdownError) {
+            this.logger.warn('telegram.rich_markdown_draft_failed', { scopeId, error: toErrorMeta(markdownError) });
+            await this.sendRichDraft(scopeId, draftId, renderTelegramMarkdownRichHtml(markdown), fallbackText);
+        }
+    }
     renderActiveStatus(active) {
         const locale = this.localeForChat(active.scopeId);
         return renderActiveTurnStatus(locale, {
@@ -8021,7 +8036,7 @@ export class BridgeSessionCore {
                 await this.sendDraft(active.scopeId, active.draftId, draftText);
             }
             else {
-                await this.sendRichDraft(active.scopeId, active.draftId, renderTelegramMarkdownRichHtml(draftText), draftText);
+                await this.sendRichMarkdownDraft(active.scopeId, active.draftId, draftText, draftText);
             }
             active.draftText = draftText;
         }
@@ -8158,28 +8173,43 @@ export class BridgeSessionCore {
             if (!existing || !chunk.trim()) {
                 continue;
             }
-            const richHtml = renderTelegramMarkdownRichHtml(chunk);
-            if (existing.richHtml === richHtml || existing.richFailedForText === chunk) {
+            if (existing.richHtml === chunk || existing.richFailedForText === chunk) {
                 continue;
             }
             try {
-                await this.messaging.editRichHtml(active.scopeId, existing.messageId, richHtml, escapeTelegramHtml(chunk));
-                existing.richHtml = richHtml;
+                await this.messaging.editRichMarkdown(active.scopeId, existing.messageId, chunk, chunk);
+                existing.richHtml = chunk;
                 existing.richFailedForText = null;
             }
-            catch (error) {
-                if (isTelegramMessageGone(error)) {
-                    segment.messages.splice(index);
-                    return;
-                }
-                existing.richFailedForText = chunk;
-                this.logger.warn('telegram.stream_rich_edit_failed', {
-                    error: String(error),
+            catch (markdownError) {
+                this.logger.warn('telegram.stream_rich_markdown_edit_failed', {
+                    error: String(markdownError),
                     turnId: active.turnId,
                     itemId: segment.itemId,
                     messageId: existing.messageId,
                     chunkIndex: index,
                 });
+                const richHtml = renderTelegramMarkdownRichHtml(chunk);
+                try {
+                    await this.messaging.editRichHtml(active.scopeId, existing.messageId, richHtml, escapeTelegramHtml(chunk));
+                    existing.richHtml = richHtml;
+                    existing.richFailedForText = null;
+                    continue;
+                }
+                catch (error) {
+                    if (isTelegramMessageGone(error)) {
+                        segment.messages.splice(index);
+                        return;
+                    }
+                    existing.richFailedForText = chunk;
+                    this.logger.warn('telegram.stream_rich_edit_failed', {
+                        error: String(error),
+                        turnId: active.turnId,
+                        itemId: segment.itemId,
+                        messageId: existing.messageId,
+                        chunkIndex: index,
+                    });
+                }
             }
         }
     }

package/dist/telegram/rich.d.ts

@@ -11,3 +11,4 @@ export interface TelegramRichMessageOptions {
     skipEntityDetection?: boolean;
 }
 export declare function telegramRichHtml(html: string, options?: TelegramRichMessageOptions): TelegramInputRichMessage;
+export declare function telegramRichMarkdown(markdown: string, options?: TelegramRichMessageOptions): TelegramInputRichMessage;

package/dist/telegram/rich.js

@@ -10,3 +10,13 @@ export function telegramRichHtml(html, options = {}) {
     }
     return message;
 }
+export function telegramRichMarkdown(markdown, options = {}) {
+    const message = { markdown };
+    if (options.isRtl) {
+        message.is_rtl = true;
+    }
+    if (options.skipEntityDetection) {
+        message.skip_entity_detection = true;
+    }
+    return message;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.39",
+  "version": "0.5.41",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",