@foxden-app/foxclaw 0.5.38 → 0.5.40

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.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
+
+### 中文
+- `/update` 被运行时活动或 auth 同步挡住时，Telegram 现在会用 RichMessage 展示具体阻塞清单，包括活跃 runtime、远端 auth 候选导入队列、最近收到时间、最近失败候选和失败原因。
+- 阻塞提示明确说明“远端 auth 候选导入队列”不等于本机 auth 文件数量，方便识别其他节点残留旧 team 账号或删除广播未同步的问题。
+
+### English
+- `/update` now reports concrete blockers as a Telegram RichMessage when runtime work or auth sync prevents a chat-driven update, including active runtimes, remote auth import backlog, last receive time, recent failed candidate, and failure reason.
+- The blocked-update message clarifies that remote auth candidate imports are not the same as local auth file count, making stale team accounts or missed delete broadcasts on another node easier to diagnose.
+
 ## 0.5.38 - 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

@@ -288,6 +288,9 @@ export declare class BridgeSessionCore {
     private handleAuthReloadCommand;
     private canRunGlobalAuthRefresh;
     private handleSelfUpdateCommand;
+    private formatSelfUpdateBlockedMessage;
+    private collectSelfUpdateBlockers;
+    private readServiceStatusForUpdateBlockers;
     private scheduleSelfUpdateStatusPoll;
     private clearSelfUpdateStatusPoll;
     private pollSelfUpdateStatus;
@@ -442,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

@@ -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)) {
@@ -4343,7 +4349,7 @@ export class BridgeSessionCore {
             return;
         }
         if (!this.isIdleForServiceUpdate() || this.store.countPendingApprovals() > 0 || this.store.countPendingUserInputs() > 0 || (this.coordinator?.canSelfUpdate && !this.coordinator.canSelfUpdate())) {
-            await this.sendMessage(scopeId, t(locale, 'update_blocked_active'));
+            await this.sendRichInternalMessage(scopeId, '/update', await this.formatSelfUpdateBlockedMessage(locale));
             return;
         }
         const status = await this.selfUpdater.readStatus();
@@ -4365,6 +4371,140 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'update_failed', { error: formatUserError(error) }));
         }
     }
+    async formatSelfUpdateBlockedMessage(locale) {
+        const blockers = await this.collectSelfUpdateBlockers(locale);
+        if (locale === 'zh') {
+            return [
+                '现在不能从 Telegram 里升级 FoxClaw，因为后台仍有活动：',
+                '',
+                ...(blockers.length > 0 ? blockers.map((blocker) => `- ${blocker}`) : [`- ${t(locale, 'update_blocked_active')}`]),
+                '',
+                '说明：远端 auth 候选导入队列不等于本机 auth 文件数量；它可能来自其他节点还没清理或没收到删除广播的旧 team 账号。',
+                '处理：普通 Codex 回复可用 /interrupt；auth 同步队列请等待消化，或在远端清理旧候选后补发删除/安全同步。终端 foxclaw update 不受这个聊天保护限制。',
+            ].join('\n');
+        }
+        return [
+            'FoxClaw cannot be updated from Telegram because background work is still active:',
+            '',
+            ...(blockers.length > 0 ? blockers.map((blocker) => `- ${blocker}`) : [`- ${t(locale, 'update_blocked_active')}`]),
+            '',
+            'Note: remote auth import backlog is not the same as the number of local auth files; it can come from stale team accounts on another node.',
+            'Action: use /interrupt for normal Codex turns; let auth sync drain, or clean the remote stale candidates and resend delete/safe-sync events. Terminal foxclaw update bypasses this chat guard.',
+        ].join('\n');
+    }
+    async collectSelfUpdateBlockers(locale) {
+        const blockers = [];
+        const pendingApprovals = this.pendingApprovalMessages.size + this.store.countPendingApprovals();
+        const pendingUserInputs = this.pendingUserInputs.size + this.store.countPendingUserInputs();
+        const localLabels = locale === 'zh'
+            ? {
+                activeTurns: '当前 runtime 活跃回复',
+                approvals: '待处理审批',
+                userInputs: '待回答问题',
+                mcp: '待处理 MCP 交互',
+                logins: '登录流程',
+                rotation: 'auth 自动轮换',
+                refreshAll: 'auth 全量刷新',
+                validation: '远端 auth 校验',
+                turnStart: '回复启动中',
+                otherRuntime: '其他 runtime 活跃',
+                weixin: '微信 runtime 活跃回复',
+                authQueue: '远端 auth 候选导入队列',
+                received: '最近收到',
+                imported: '最近导入',
+                failed: '最近失败',
+                lease: 'auth 同步租约',
+                error: 'auth 同步错误',
+                coordinator: '服务协调器报告仍忙',
+            }
+            : {
+                activeTurns: 'Current runtime active turns',
+                approvals: 'Pending approvals',
+                userInputs: 'Pending questions',
+                mcp: 'Pending MCP interactions',
+                logins: 'Login flows',
+                rotation: 'Auth rotation',
+                refreshAll: 'Auth refresh-all',
+                validation: 'Remote auth validation',
+                turnStart: 'Turn startup',
+                otherRuntime: 'Other runtime active turns',
+                weixin: 'Weixin runtime active turns',
+                authQueue: 'Remote auth candidate import queue',
+                received: 'last received',
+                imported: 'last imported',
+                failed: 'recent failure',
+                lease: 'Auth sync lease',
+                error: 'Auth sync error',
+                coordinator: 'Service coordinator reports busy',
+            };
+        if (this.activeTurns.size > 0)
+            blockers.push(`${localLabels.activeTurns}: ${this.activeTurns.size}`);
+        if (pendingApprovals > 0)
+            blockers.push(`${localLabels.approvals}: ${pendingApprovals}`);
+        if (pendingUserInputs > 0)
+            blockers.push(`${localLabels.userInputs}: ${pendingUserInputs}`);
+        if (this.pendingMcpElicitations.size > 0)
+            blockers.push(`${localLabels.mcp}: ${this.pendingMcpElicitations.size}`);
+        if (this.pendingLoginsByScope.size > 0)
+            blockers.push(`${localLabels.logins}: ${this.pendingLoginsByScope.size}`);
+        if (this.authRotationInProgress)
+            blockers.push(localLabels.rotation);
+        if (this.authRefreshAllInProgress)
+            blockers.push(localLabels.refreshAll);
+        if (this.externalAuthValidationInProgress)
+            blockers.push(localLabels.validation);
+        if (this.turnStartInProgress > 0)
+            blockers.push(`${localLabels.turnStart}: ${this.turnStartInProgress}`);
+        const serviceStatus = await this.readServiceStatusForUpdateBlockers();
+        if (serviceStatus) {
+            const activeBots = serviceStatus.bots
+                .filter((runtime) => runtime.activeTurns > 0)
+                .map((runtime) => `${runtime.username ? `@${runtime.username}` : runtime.id} ${runtime.activeTurns}`);
+            if (activeBots.length > 0) {
+                blockers.push(`${localLabels.otherRuntime}: ${activeBots.join(', ')}`);
+            }
+            if ((serviceStatus.weixinRuntime?.activeTurns ?? 0) > 0) {
+                blockers.push(`${localLabels.weixin}: ${serviceStatus.weixinRuntime.activeTurns}`);
+            }
+            const authSync = serviceStatus.authSync;
+            if (authSync?.enabled) {
+                if (authSync.pendingImports > 0) {
+                    const details = [
+                        authSync.lastReceivedAt ? `${localLabels.received} ${authSync.lastReceivedAt}` : null,
+                        authSync.lastImportedAt ? `${localLabels.imported} ${authSync.lastImportCandidate ?? authSync.lastImportedAt}` : null,
+                    ].filter(Boolean);
+                    blockers.push(`${localLabels.authQueue}: ${authSync.pendingImports}${details.length > 0 ? ` (${details.join('; ')})` : ''}`);
+                }
+                const latestFailure = authSync.candidateFailures?.[0] ?? null;
+                if (latestFailure) {
+                    const source = latestFailure.sourceLabel ?? latestFailure.peer ?? latestFailure.sourceNodeId;
+                    blockers.push(`${localLabels.failed}: ${latestFailure.candidateName}: ${latestFailure.reason}${source ? ` (${source})` : ''}`);
+                }
+                if (authSync.activeLeaseId)
+                    blockers.push(`${localLabels.lease}: ${authSync.activeLeaseId}`);
+                if (authSync.lastError)
+                    blockers.push(`${localLabels.error}: ${authSync.lastError}`);
+            }
+        }
+        else if (this.coordinator?.canSelfUpdate && !this.coordinator.canSelfUpdate()) {
+            blockers.push(localLabels.coordinator);
+        }
+        if (blockers.length === 0 && this.coordinator?.canSelfUpdate && !this.coordinator.canSelfUpdate()) {
+            blockers.push(localLabels.coordinator);
+        }
+        return blockers;
+    }
+    async readServiceStatusForUpdateBlockers() {
+        if (!this.coordinator?.getServiceStatus)
+            return null;
+        try {
+            return await this.coordinator.getServiceStatus();
+        }
+        catch (error) {
+            this.logger.warn('self_update.service_status_failed', { error: toErrorMeta(error) });
+            return null;
+        }
+    }
     scheduleSelfUpdateStatusPoll(delay = SELF_UPDATE_STATUS_POLL_MS) {
         if (!this.selfUpdater || this.selfUpdatePollTimer) {
             return;
@@ -7638,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, {
@@ -7887,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;
         }
@@ -8024,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.38",
+  "version": "0.5.40",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",