@foxden-app/foxclaw 0.13.7 → 0.13.8

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.13.8 - 2026-10-06
+
+### 中文
+
+- 任务结束后将所有过程小结合并为一条默认收起的 Telegram 归档消息：收起显示总耗时与 Token 总/入/出/缓存，展开按时间段展示全部小结；最终结论独立保留，移除其他小结和工作状态卡。
+- Codex 按本轮模型请求累计原生 Token 用量，忽略重复及其他会话/轮次通知；未提供的计数显示“—”。记录任务与小结时间，交付重试不增加耗时。
+- 超过富消息文字或内容块上限时，在同一归档内显示几条预览及“查看全部小结”HTML 文件，保留完整内容，不额外发布消息或公开网页。合并成功后才删除原消息，持久化清理进度；失败可通过重启或 `/recover` 继续，避免丢失小结或重发最终结论。
+
+### English
+
+- Consolidate all progress summaries into one closed Telegram archive at completion. Its header shows duration and total/input/output/cached tokens; expand to see timed summaries. Keep the final answer separate and remove other summaries and the working card.
+- Accumulate native Codex token usage for this turn's model requests, excluding duplicate and foreign notifications. Show unavailable counters as “—”. Persist task and summary timing so delivery retries do not inflate duration.
+- When rich message text or block limits are exceeded, embed previews and a complete HTML archive in the same message. No extra messages or public hosting. Delete originals only after successful consolidation and persist cleanup checkpoints; resume failures after restart or through `/recover` without losing summaries or resending the final answer.
+
 ## 0.13.7 - 2026-10-06
 
 ### 中文

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

@@ -3,6 +3,7 @@ import type { ChannelTextEvent } from '../../core/channel_events.js';
 import type { ChannelPort } from '../../core/channel_port.js';
 import type { TelegramGateway } from '../../telegram/gateway.js';
 import type { TelegramRemoteFile } from '../../telegram/api.js';
+import type { TaskCommentaryArchive } from '../../core/commentary_archive.js';
 export type InlineKeyboard = Array<Array<{
     text: string;
     callback_data: string;
@@ -18,6 +19,7 @@ export declare class TelegramMessagingPort implements ChannelPort {
     updateTaskPreview(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
     endTaskPreview(scopeId: string, taskId: string): Promise<void>;
     sendTaskCommentary(scopeId: string, text: string): Promise<number>;
+    archiveTaskCommentary(scopeId: string, messageId: number, archive: TaskCommentaryArchive): Promise<void>;
     foldTaskCommentary(scopeId: string, messageId: number, text: string): Promise<void>;
     readonly capabilities: {
         editableMessages: boolean;

package/dist/channels/telegram/telegram_messaging_port.js

@@ -6,6 +6,7 @@ import { parseTelegramTargetFromBridgeScope } from '../../core/bridge_scope.js';
 import { renderTelegramMarkdownRichHtml } from '../../telegram/rich_markdown.js';
 import { escapeTelegramHtml } from '../../telegram/html.js';
 import { telegramRichHtml, telegramRichMarkdown } from '../../telegram/rich.js';
+import { buildTelegramCommentaryArchive } from '../../telegram/commentary_archive.js';
 /**
  * Telegram outbound operations addressed by bridge scope id (`telegram:…`).
  */
@@ -22,6 +23,16 @@ export class TelegramMessagingPort {
     async sendTaskCommentary(scopeId, text) {
         return this.sendRichMarkdown(scopeId, text);
     }
+    async archiveTaskCommentary(scopeId, messageId, archive) {
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        const rendered = buildTelegramCommentaryArchive(archive);
+        if (rendered.document) {
+            await this.gateway.editRichMessageWithDocument(target.chatId, messageId, rendered.html, rendered.document);
+        }
+        else {
+            await this.gateway.editRichMessage(target.chatId, messageId, telegramRichHtml(rendered.html, { skipEntityDetection: true }), []);
+        }
+    }
     async foldTaskCommentary(scopeId, messageId, text) {
         const target = parseTelegramTargetFromBridgeScope(scopeId);
         try {

package/dist/codex_app/adapter.js

@@ -41,6 +41,8 @@ export class CodexEngineAdapter {
         let turnId = null;
         let cancelled = false;
         const earlyNotifications = [];
+        let usage;
+        let lastUsageTotal;
         let promptText = request.prompt;
         if (request.stagedAttachments && request.stagedAttachments.length > 0 && !request.prompt.includes('Telegram attachments:')) {
             promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
@@ -68,6 +70,27 @@ export class CodexEngineAdapter {
                 return;
             }
             try {
+                if (msg.method === 'thread/tokenUsage/updated') {
+                    if (msg.params?.turnId && msg.params.turnId !== turnId)
+                        return;
+                    const native = msg.params?.tokenUsage;
+                    const current = native?.last;
+                    if (!current)
+                        return;
+                    // `last` is one model request; `total` is cumulative for the thread.
+                    // Repeated notifications with the same cumulative counters are not new usage.
+                    const signature = native.total ? JSON.stringify(native.total) : undefined;
+                    if (signature && signature === lastUsageTotal)
+                        return;
+                    lastUsageTotal = signature;
+                    usage ??= {};
+                    for (const [key, nativeKey] of [['inputTokens', 'inputTokens'], ['outputTokens', 'outputTokens'], ['cachedTokens', 'cachedInputTokens'], ['totalTokens', 'totalTokens']]) {
+                        const value = current[nativeKey];
+                        if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+                            usage[key] = (usage[key] ?? 0) + value;
+                    }
+                    return;
+                }
                 const ev = normalizeTurnActivityEvent(msg);
                 if (!ev)
                     return;
@@ -123,6 +146,7 @@ export class CodexEngineAdapter {
                         ...(failure ? { error: String(failure) } : {}),
                         response: accumulatedResponse,
                         conversationId: threadId,
+                        usage,
                     };
                     emitter.emit('result', finalResult);
                     resolveWaiters(finalResult);
@@ -142,7 +166,7 @@ export class CodexEngineAdapter {
                 return;
             cleanup();
             finalResult = { kind: 'result', status: 'ERROR', response: responseText(),
-                error: 'Codex connection closed before the task outcome was confirmed.', outcomeUnknown: true, conversationId: threadId };
+                error: 'Codex connection closed before the task outcome was confirmed.', outcomeUnknown: true, conversationId: threadId, usage };
             emitter.emit('result', finalResult);
             resolveWaiters(finalResult);
         };
@@ -271,7 +295,7 @@ export class CodexEngineAdapter {
                     if (threadId && turnId)
                         await this.client.interruptTurn(threadId, turnId);
                     cleanup();
-                    finalResult = { kind: 'result', status: 'INTERRUPTED', response: accumulatedResponse, conversationId: threadId };
+                    finalResult = { kind: 'result', status: 'INTERRUPTED', response: accumulatedResponse, conversationId: threadId, usage };
                     emitter.emit('result', finalResult);
                     resolveWaiters(finalResult);
                 })();

package/dist/core/channel_port.d.ts

@@ -3,6 +3,7 @@ import type { AppLocale } from '../types.js';
 import type { ChannelTextEvent, ChannelCallbackEvent, ChannelInbound } from './channel_events.js';
 import type { ParsedCommand } from '../controller/commands.js';
 import type { AttachmentDownloader } from './attachments.js';
+import type { TaskCommentaryArchive } from './commentary_archive.js';
 /** Bridge-local handles; a transport maps these to its native message identifiers. */
 export type ChannelMessageRef = number;
 export type ChannelInlineKeyboard = Array<Array<{
@@ -34,6 +35,7 @@ export interface ChannelPort extends AttachmentDownloader {
     updateTaskPreview?(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
     sendTaskCommentary?(scopeId: string, text: string): Promise<number>;
     foldTaskCommentary?(scopeId: string, messageId: number, text: string): Promise<void>;
+    archiveTaskCommentary?(scopeId: string, messageId: number, archive: TaskCommentaryArchive): Promise<void>;
     endTaskPreview?(scopeId: string, taskId: string): Promise<void>;
     resolveAction?(event: ChannelTextEvent): ChannelCallbackEvent | null;
     editPlain(scopeId: string, messageId: ChannelMessageRef, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;

package/dist/core/commentary_archive.d.ts

@@ -0,0 +1,13 @@
+import type { AppLocale } from '../types.js';
+import type { EngineTurnResult } from './engine_spi.js';
+export interface TaskCommentaryArchive {
+    startedAt: number;
+    endedAt: number;
+    locale: AppLocale;
+    usage?: EngineTurnResult['usage'];
+    entries: Array<{
+        text: string;
+        startedAt?: number | undefined;
+        endedAt?: number | undefined;
+    }>;
+}

package/dist/core/commentary_archive.js

@@ -0,0 +1 @@
+export {};

package/dist/core/orchestrator.d.ts

@@ -30,6 +30,7 @@ export interface UnifiedActiveTurn {
     settling?: boolean;
     separateFinal?: boolean;
     commentaryIds?: Set<string>;
+    lastCommentaryTime?: number;
 }
 export declare class UnifiedChannelOrchestrator {
     readonly config: AppConfig;

package/dist/core/orchestrator.js

@@ -539,7 +539,7 @@ export class UnifiedChannelOrchestrator {
             const task = this.store.taskJournal.get(turn.taskId);
             const folded = buildFoldedToolsSummary({ toolLines: turn.toolLines, toolCount: turn.toolCount, stepIndex: turn.stepIndex, startTime: turn.startTime, locale: task.request.locale });
             const response = `${task.request.locale === 'zh' ? '🛑 已停止任务；排队任务保留。' : '🛑 Task stopped; queued tasks kept.'}${turn.accumulatedText.trim() ? `\n\n${turn.accumulatedText.trim()}` : ''}`;
-            this.store.taskJournal.update(turn.taskId, 'delivery_pending', { result: { kind: 'result', status: 'INTERRUPTED', response, conversationId: turn.threadId }, delivery: combineSummaryAndResponse(folded, response), deliveredChunks: 0, previewMessageId: turn.messageId, separateFinal: turn.separateFinal === true });
+            this.store.taskJournal.update(turn.taskId, 'delivery_pending', { result: { kind: 'result', status: 'INTERRUPTED', response, conversationId: turn.threadId }, taskEndedAt: Date.now(), delivery: turn.separateFinal ? chunkMessage(response) : combineSummaryAndResponse(folded, response), deliveredChunks: 0, previewMessageId: turn.messageId, separateFinal: turn.separateFinal === true });
             try {
                 await this.deliverTaskChunks(turn.taskId);
                 this.resolveDeliveredTask(turn.taskId);
@@ -635,27 +635,60 @@ export class UnifiedChannelOrchestrator {
             task = this.store.taskJournal.update(task.id, 'delivery_pending', { deliveredChunks: index + 1 });
         }
         if (task.separateFinal) {
-            for (let index = 0; index < (task.commentary?.length ?? 0); index++) {
-                const item = task.commentary[index];
-                if (item.folded || this.messaging.capabilities?.editableMessages === false)
-                    continue;
-                try {
-                    if (this.messaging.foldTaskCommentary)
-                        await this.messaging.foldTaskCommentary(task.event.scopeId, item.messageId, item.text);
-                    else
-                        await this.editMessage(task.event.scopeId, item.messageId, `<blockquote expandable>${escapeHtml(item.text)}</blockquote>`, []);
+            if (task.commentary?.length && this.messaging.archiveTaskCommentary && this.messaging.capabilities?.editableMessages !== false) {
+                const messageId = task.commentaryArchiveMessageId ?? task.commentary[0].messageId;
+                if (!task.commentaryArchiveReady) {
+                    const entries = [];
+                    let previousSource;
+                    for (const item of task.commentary) {
+                        if (item.sourceMessageId && item.sourceMessageId === previousSource)
+                            entries.at(-1).text += `\n${item.text}`;
+                        else
+                            entries.push({ text: item.text, startedAt: item.startedAt, endedAt: item.endedAt });
+                        previousSource = item.sourceMessageId;
+                    }
+                    await this.messaging.archiveTaskCommentary(task.event.scopeId, messageId, {
+                        startedAt: task.taskStartedAt ?? task.createdAt, endedAt: task.taskEndedAt ?? task.updatedAt,
+                        locale: task.request.locale, usage: task.result?.usage, entries,
+                    });
+                    task = this.store.taskJournal.update(task.id, 'delivery_pending', { commentaryArchiveMessageId: messageId, commentaryArchiveReady: true, commentary: task.commentary.map(item => ({ ...item, folded: false })) });
+                }
+                for (let index = 0; index < task.commentary.length; index++) {
+                    const item = task.commentary[index];
+                    if (item.folded)
+                        continue;
+                    if (item.messageId !== messageId)
+                        await this.messaging.deleteMessage(task.event.scopeId, item.messageId);
                     const commentary = [...task.commentary];
                     commentary[index] = { ...item, folded: true };
                     task = this.store.taskJournal.update(task.id, 'delivery_pending', { commentary });
                 }
-                catch (error) {
-                    this.logger.warn('orchestrator.commentary_fold_failed', { taskId, messageId: item.messageId, error: String(error) });
+            }
+            else {
+                for (let index = 0; index < (task.commentary?.length ?? 0); index++) {
+                    const item = task.commentary[index];
+                    if (item.folded || this.messaging.capabilities?.editableMessages === false)
+                        continue;
+                    try {
+                        if (this.messaging.foldTaskCommentary)
+                            await this.messaging.foldTaskCommentary(task.event.scopeId, item.messageId, item.text);
+                        else
+                            await this.editMessage(task.event.scopeId, item.messageId, `<blockquote expandable>${escapeHtml(item.text)}</blockquote>`, []);
+                        const commentary = [...task.commentary];
+                        commentary[index] = { ...item, folded: true };
+                        task = this.store.taskJournal.update(task.id, 'delivery_pending', { commentary });
+                    }
+                    catch (error) {
+                        this.logger.warn('orchestrator.commentary_fold_failed', { taskId, messageId: item.messageId, error: String(error) });
+                    }
                 }
             }
             if (!task.previewSettled) {
                 if (task.previewMessageId > 0 && this.messaging.capabilities?.editableMessages !== false) {
-                    if (task.finalPreviewText)
+                    if (task.finalPreviewText && !task.commentaryArchiveReady)
                         await this.editMessage(task.event.scopeId, task.previewMessageId, task.finalPreviewText, []);
+                    else if (task.commentaryArchiveReady)
+                        await this.messaging.deleteMessage(task.event.scopeId, task.previewMessageId);
                     else
                         await this.messaging.deleteMessage(task.event.scopeId, task.previewMessageId).catch(() => { });
                 }
@@ -1151,7 +1184,8 @@ export class UnifiedChannelOrchestrator {
             throw new Error('Orchestrator is stopped');
         }
         let execution;
-        task = this.store.taskJournal.update(task.id, 'running', { result: null, delivery: [], deliveredChunks: 0, previewSettled: false, separateFinal: adapter.supportsCommentary === true });
+        const taskStartedAt = task.taskStartedAt ?? Date.now();
+        task = this.store.taskJournal.update(task.id, 'running', { result: null, delivery: [], deliveredChunks: 0, previewSettled: false, separateFinal: adapter.supportsCommentary === true, taskStartedAt });
         try {
             execution = adapter.executeTurn(req);
         }
@@ -1174,12 +1208,13 @@ export class UnifiedChannelOrchestrator {
             stepIndex: 1,
             toolCount: 0,
             currentTool: null,
-            startTime: Date.now(),
+            startTime: taskStartedAt,
             previewKey: turnKey,
             queueId: options?.queueId,
             taskId: task.id,
             separateFinal: adapter.supportsCommentary === true,
             commentaryIds: new Set(),
+            lastCommentaryTime: task.commentary?.at(-1)?.endedAt ?? taskStartedAt,
         };
         this.activeTurns.set(scopeId, activeTurn);
         this.messaging.sendTypingInScope(scopeId).catch(() => { });
@@ -1242,6 +1277,9 @@ export class UnifiedChannelOrchestrator {
             activeTurn.commentaryIds?.add(message.messageId);
             activeTurn.separateFinal = true;
             activeTurn.accumulatedText = '';
+            const endedAt = Date.now();
+            const startedAt = activeTurn.lastCommentaryTime ?? activeTurn.startTime;
+            activeTurn.lastCommentaryTime = endedAt;
             void this.messageOperations.run(`${scopeId}:preview:${activeTurn.taskId}`, async () => {
                 if (!ownsTurn())
                     return;
@@ -1252,7 +1290,7 @@ export class UnifiedChannelOrchestrator {
                         : await this.messaging.sendRichMarkdown(scopeId, text);
                     const current = this.store.taskJournal.get(activeTurn.taskId);
                     this.store.taskJournal.update(current.id, current.state, {
-                        commentary: [...(current.commentary ?? []), { messageId, text, folded: false }], separateFinal: true,
+                        commentary: [...(current.commentary ?? []), { messageId, text, folded: false, sourceMessageId: message.messageId, startedAt, endedAt }], separateFinal: true,
                     });
                 }
             }).catch(error => this.logger.warn('orchestrator.commentary_send_failed', { taskId: activeTurn.taskId, error: String(error) }));
@@ -1325,7 +1363,9 @@ export class UnifiedChannelOrchestrator {
             const task = this.store.taskJournal.get(activeTurn.taskId);
             if (task.state === 'awaiting_confirmation')
                 return;
-            if (task.state === 'delivery_pending' && task.deliveredChunks < task.delivery.length) {
+            if (task.state === 'delivery_pending' && (task.deliveredChunks < task.delivery.length
+                || (task.separateFinal && this.messaging.archiveTaskCommentary && this.messaging.capabilities?.editableMessages !== false && task.commentary?.length && (!task.commentaryArchiveReady || task.commentary.some(item => !item.folded)))
+                || (task.separateFinal && !task.previewSettled))) {
                 this.logger.warn('orchestrator.delivery_pending', { taskId: task.id, scopeId });
                 return;
             }
@@ -1340,7 +1380,7 @@ export class UnifiedChannelOrchestrator {
                 if (!ownsTurn() || activeTurn.settling)
                     return;
                 activeTurn.settling = true;
-                this.store.taskJournal.update(activeTurn.taskId, 'running', { result: res, request: { ...req, threadId: res.conversationId || activeTurn.threadId } });
+                this.store.taskJournal.update(activeTurn.taskId, 'running', { result: res, taskEndedAt: Date.now(), request: { ...req, threadId: res.conversationId || activeTurn.threadId } });
                 try {
                     if (activeTurn.flushTimer)
                         clearTimeout(activeTurn.flushTimer);
@@ -1471,7 +1511,7 @@ export class UnifiedChannelOrchestrator {
                 if (!ownsTurn() || activeTurn.settling)
                     return;
                 activeTurn.settling = true;
-                this.store.taskJournal.update(activeTurn.taskId, 'running', { result: { kind: 'result', status: 'ERROR', response: activeTurn.accumulatedText, error: err.message, conversationId: activeTurn.threadId } });
+                this.store.taskJournal.update(activeTurn.taskId, 'running', { taskEndedAt: Date.now(), result: { kind: 'result', status: 'ERROR', response: activeTurn.accumulatedText, error: err.message, conversationId: activeTurn.threadId } });
                 try {
                     if (activeTurn.flushTimer)
                         clearTimeout(activeTurn.flushTimer);

package/dist/store/task_journal.d.ts

@@ -16,7 +16,14 @@ export interface JournalTask {
         messageId: number;
         text: string;
         folded: boolean;
+        sourceMessageId?: string;
+        startedAt?: number;
+        endedAt?: number;
     }>;
+    taskStartedAt?: number;
+    taskEndedAt?: number;
+    commentaryArchiveMessageId?: number;
+    commentaryArchiveReady?: boolean;
     separateFinal?: boolean;
     finalPreviewText?: string;
     previewSettled?: boolean;

package/dist/telegram/commentary_archive.d.ts

@@ -0,0 +1,11 @@
+import type { TaskCommentaryArchive } from '../core/commentary_archive.js';
+export interface TelegramCommentaryArchive {
+    html: string;
+    document?: {
+        filename: string;
+        contents: Buffer;
+        contentType: string;
+    };
+}
+export declare function commentaryArchiveHeader(archive: TaskCommentaryArchive): string;
+export declare function buildTelegramCommentaryArchive(archive: TaskCommentaryArchive): TelegramCommentaryArchive;

package/dist/telegram/commentary_archive.js

@@ -0,0 +1,36 @@
+import { escapeTelegramHtml } from './html.js';
+import { renderTelegramMarkdownRichHtml } from './rich_markdown.js';
+export function commentaryArchiveHeader(archive) {
+    const zh = archive.locale === 'zh';
+    const seconds = Math.max(0, Math.round((archive.endedAt - archive.startedAt) / 1000));
+    const duration = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+    const count = (n) => typeof n === 'number' && Number.isFinite(n) ? Math.round(Math.max(0, n)).toLocaleString('en-US') : '—';
+    const usage = archive.usage;
+    const total = usage?.totalTokens ?? (usage?.inputTokens !== undefined && usage.outputTokens !== undefined ? usage.inputTokens + usage.outputTokens : undefined);
+    return `${zh ? '总时间' : 'Total time'}: ${duration}  ${zh ? 'Token（总/入/出/缓存）' : 'Tokens (total/in/out/cache)'}: ${[total, usage?.inputTokens, usage?.outputTokens, usage?.cachedTokens].map(count).join('/')}`;
+}
+function interval(entry) {
+    const clock = (time) => time === undefined ? '—' : new Date(time).toLocaleTimeString('en-GB', { hour12: false });
+    return `${clock(entry.startedAt)}–${clock(entry.endedAt)}`;
+}
+function entryHtml(entry) {
+    return `<p><b>${escapeTelegramHtml(interval(entry))}</b></p>${renderTelegramMarkdownRichHtml(entry.text)}`;
+}
+export function buildTelegramCommentaryArchive(archive) {
+    const header = commentaryArchiveHeader(archive);
+    const body = archive.entries.map(entryHtml).join('\n');
+    const wrap = (content) => `<details><summary>${escapeTelegramHtml(header)}</summary>${content}</details>`;
+    const html = wrap(body);
+    // Conservative budgets also cover expanded entities and nested list blocks.
+    const blocks = (html.match(/<(?:p|h[1-6]|pre|ul|ol|li|blockquote|details)\b/g) ?? []).length;
+    if (html.length <= 30000 && blocks <= 450)
+        return { html };
+    const zh = archive.locale === 'zh';
+    const preview = archive.entries.slice(0, 3).map(entry => entryHtml({ ...entry, text: entry.text.length > 600 ? `${entry.text.slice(0, 600)}…` : entry.text })).join('\n');
+    const label = zh ? '查看全部小结' : 'View all summaries';
+    const fullDocument = `<!doctype html><html lang="${zh ? 'zh' : 'en'}"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'"><title>${label}</title><style>body{font:16px/1.7 system-ui,sans-serif;max-width:900px;margin:24px auto;padding:0 20px;overflow-wrap:anywhere}pre{white-space:pre-wrap;background:#f3f4f6;padding:12px}code{font-family:monospace}</style><body><h1>${escapeTelegramHtml(header)}</h1>${body}</body></html>`;
+    return {
+        html: wrap(`${preview}<p>${zh ? `共 ${archive.entries.length} 条小结，完整内容见下方文件。` : `${archive.entries.length} summaries; complete content in the file below.`}</p><figure><tg-document src="tg://document?id=commentary_archive"></tg-document><figcaption>${label}</figcaption></figure>`),
+        document: { filename: zh ? '查看全部小结.html' : 'all-summaries.html', contents: Buffer.from(fullDocument), contentType: 'text/html' },
+    };
+}

package/dist/telegram/gateway.d.ts

@@ -75,6 +75,11 @@ export declare class TelegramGateway extends EventEmitter {
         text: string;
         callback_data: string;
     }>>): Promise<void>;
+    editRichMessageWithDocument(chatId: string, messageId: number, html: string, document: {
+        filename: string;
+        contents: Buffer;
+        contentType: string;
+    }): Promise<void>;
     clearMessageInlineKeyboard(chatId: string, messageId: number): Promise<void>;
     private sendMessageWithOptions;
     private editMessageWithOptions;

package/dist/telegram/gateway.js

@@ -180,6 +180,17 @@ export class TelegramGateway extends EventEmitter {
             throw new Error(result.description || 'Failed to edit Telegram rich message');
         }
     }
+    async editRichMessageWithDocument(chatId, messageId, html, document) {
+        const result = await callTelegramMultipartApi(this.botToken, 'editMessageText', {
+            chat_id: chatId, message_id: String(messageId),
+            rich_message: JSON.stringify({ html, skip_entity_detection: true,
+                media: [{ id: 'commentary_archive', media: { type: 'document', media: 'attach://commentary_archive' } }] }),
+            reply_markup: JSON.stringify({ inline_keyboard: [] }),
+        }, [{ fieldName: 'commentary_archive', ...document }]);
+        if (!result.ok && !String(result.description || '').includes('message is not modified')) {
+            throw new Error(result.description || 'Failed to attach commentary archive');
+        }
+    }
     async clearMessageInlineKeyboard(chatId, messageId) {
         const result = await callTelegramApi(this.botToken, 'editMessageReplyMarkup', {
             chat_id: chatId,
@@ -222,7 +233,7 @@ export class TelegramGateway extends EventEmitter {
             chat_id: chatId,
             message_id: messageId,
         });
-        if (!result.ok) {
+        if (!result.ok && !String(result.description || '').includes('message to delete not found')) {
             throw new Error(result.description || 'Failed to delete Telegram message');
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.13.7",
+  "version": "0.13.8",
   "description": "Foxden local execution claw for controlling Codex, OpenCode, Antigravity, and DeepSeek Harness from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",