@fonz/tgcc 0.6.13 → 0.6.15

package/dist/streaming.d.ts

@@ -2,6 +2,7 @@ import type { StreamInnerEvent } from './cc-protocol.js';
 export interface TelegramSender {
     sendMessage(chatId: number | string, text: string, parseMode?: string): Promise<number>;
     editMessage(chatId: number | string, messageId: number, text: string, parseMode?: string): Promise<void>;
+    deleteMessage?(chatId: number | string, messageId: number): Promise<void>;
     sendPhoto?(chatId: number | string, imageBuffer: Buffer, caption?: string): Promise<number>;
 }
 export interface TurnUsage {
@@ -16,6 +17,13 @@ export interface StreamAccumulatorOptions {
     sender: TelegramSender;
     editIntervalMs?: number;
     splitThreshold?: number;
+    logger?: {
+        error?: (...args: unknown[]) => void;
+        warn?: (...args: unknown[]) => void;
+        debug?: (...args: unknown[]) => void;
+    };
+    /** Callback for critical errors that should be surfaced to the user */
+    onError?: (err: unknown, context: string) => void;
 }
 /** Escape characters that are special in Telegram HTML. */
 export declare function escapeHtml(text: string): string;
@@ -36,6 +44,8 @@ export declare class StreamAccumulator {
     private sender;
     private editIntervalMs;
     private splitThreshold;
+    private logger?;
+    private onError?;
     private tgMessageId;
     private buffer;
     private thinkingBuffer;
@@ -44,11 +54,13 @@ export declare class StreamAccumulator {
     private lastEditTime;
     private editTimer;
     private thinkingIndicatorShown;
-    private toolIndicators;
     private messageIds;
     private finished;
     private sendQueue;
     private turnUsage;
+    private toolMessages;
+    private toolInputBuffers;
+    private currentToolBlockId;
     constructor(options: StreamAccumulatorOptions);
     get allMessageIds(): number[];
     /** Set usage stats for the current turn (called from bridge on result event) */
@@ -60,7 +72,19 @@ export declare class StreamAccumulator {
     private sendOrEdit;
     private _doSendOrEdit;
     private sendImage;
-    private showToolIndicator;
+    /** Send an independent tool indicator message (not through the accumulator's sendOrEdit). */
+    private sendToolIndicator;
+    /** Update a tool indicator message with input preview once the JSON value is complete. */
+    private toolIndicatorLastSummary;
+    private updateToolIndicatorWithInput;
+    /** Resolve a tool indicator with success/failure status. Edits to a compact summary with input detail. */
+    resolveToolMessage(blockId: string, isError: boolean, errorMessage?: string, resultContent?: string, toolUseResult?: Record<string, unknown>): Promise<void>;
+    /** Edit a specific tool indicator message by block ID. */
+    editToolMessage(blockId: string, html: string): Promise<void>;
+    /** Delete a specific tool indicator message by block ID. */
+    deleteToolMessage(blockId: string): Promise<void>;
+    /** Delete all tool indicator messages. */
+    deleteAllToolMessages(): Promise<void>;
     private throttledEdit;
     /** Build the full message text including thinking blockquote prefix and usage footer.
      *  Returns { text, hasHtmlSuffix } — caller must pass rawHtml=true when hasHtmlSuffix is set
@@ -73,10 +97,12 @@ export declare class StreamAccumulator {
     private forceSplitOrTruncate;
     finalize(): Promise<void>;
     private clearEditTimer;
-    /** Soft reset: clear buffer/state but keep tgMessageId so next turn edits the same message */
+    /** Soft reset: clear buffer/state but keep tgMessageId so next turn edits the same message.
+     *  toolMessages persists across resets — they are independent of the text accumulator. */
     softReset(): void;
     /** Full reset: also clears tgMessageId (next send creates a new message).
-     *  Chains on the existing sendQueue so any pending finalize() edits complete first. */
+     *  Chains on the existing sendQueue so any pending finalize() edits complete first.
+     *  toolMessages persists — they are independent fire-and-forget messages. */
     reset(): void;
 }
 /** Format usage stats as an HTML italic footer line */

package/dist/streaming.js

@@ -34,6 +34,8 @@ export class StreamAccumulator {
     sender;
     editIntervalMs;
     splitThreshold;
+    logger;
+    onError;
     // State
     tgMessageId = null;
     buffer = '';
@@ -43,16 +45,21 @@ export class StreamAccumulator {
     lastEditTime = 0;
     editTimer = null;
     thinkingIndicatorShown = false;
-    toolIndicators = [];
     messageIds = []; // all message IDs sent during this turn
     finished = false;
     sendQueue = Promise.resolve();
     turnUsage = null;
+    // Per-tool-use independent indicator messages (persists across resets)
+    toolMessages = new Map();
+    toolInputBuffers = new Map(); // tool block ID → accumulated input JSON
+    currentToolBlockId = null;
     constructor(options) {
         this.chatId = options.chatId;
         this.sender = options.sender;
         this.editIntervalMs = options.editIntervalMs ?? 1000;
         this.splitThreshold = options.splitThreshold ?? 4000;
+        this.logger = options.logger;
+        this.onError = options.onError;
     }
     get allMessageIds() { return [...this.messageIds]; }
     /** Set usage stats for the current turn (called from bridge on result event) */
@@ -91,20 +98,23 @@ export class StreamAccumulator {
         if (blockType === 'thinking') {
             this.currentBlockType = 'thinking';
             if (!this.thinkingIndicatorShown && !this.buffer) {
-                await this.sendOrEdit('<i>💭 Thinking...</i>', true);
+                await this.sendOrEdit('<blockquote>💭 Thinking...</blockquote>', true);
                 this.thinkingIndicatorShown = true;
             }
         }
         else if (blockType === 'text') {
             this.currentBlockType = 'text';
-            // Clear tool indicators when real text starts
-            this.toolIndicators = [];
+            // Text always gets its own message — don't touch tool indicator messages
+            if (!this.tgMessageId) {
+                // Will create a new message on next sendOrEdit
+            }
         }
         else if (blockType === 'tool_use') {
             this.currentBlockType = 'tool_use';
-            const name = event.content_block.name;
-            this.toolIndicators.push(name);
-            await this.showToolIndicator(name);
+            const block = event.content_block;
+            this.currentToolBlockId = block.id;
+            // Send an independent indicator message for this tool_use block
+            await this.sendToolIndicator(block.id, block.name);
         }
         else if (blockType === 'image') {
             this.currentBlockType = 'image';
@@ -130,22 +140,37 @@ export class StreamAccumulator {
                 this.thinkingBuffer += delta.thinking;
             }
         }
+        else if (this.currentBlockType === 'tool_use' && 'delta' in event) {
+            const delta = event.delta;
+            if (delta?.type === 'input_json_delta' && delta.partial_json && this.currentToolBlockId) {
+                const blockId = this.currentToolBlockId;
+                const prev = this.toolInputBuffers.get(blockId) ?? '';
+                this.toolInputBuffers.set(blockId, prev + delta.partial_json);
+                // Update indicator with input preview once we have enough
+                await this.updateToolIndicatorWithInput(blockId);
+            }
+        }
         else if (this.currentBlockType === 'image' && 'delta' in event) {
             const delta = event.delta;
             if (delta?.type === 'image_delta' && delta.data) {
                 this.imageBase64Buffer += delta.data;
             }
         }
-        // Ignore input_json_delta content
     }
     // ── TG message management ──
     /** Send or edit a message. If rawHtml is true, text is already HTML-safe. */
     async sendOrEdit(text, rawHtml = false) {
-        this.sendQueue = this.sendQueue.then(() => this._doSendOrEdit(text, rawHtml));
+        this.sendQueue = this.sendQueue.then(() => this._doSendOrEdit(text, rawHtml)).catch(err => {
+            this.logger?.error?.({ err }, 'sendOrEdit failed');
+            this.onError?.(err, 'Failed to send/edit message');
+        });
         return this.sendQueue;
     }
     async _doSendOrEdit(text, rawHtml = false) {
-        const safeText = (rawHtml ? text : makeHtmlSafe(text)) || '...';
+        let safeText = (rawHtml ? text : makeHtmlSafe(text)) || '...';
+        // Guard against HTML that has tags but no visible text content (e.g. "<b></b>")
+        if (!safeText.replace(/<[^>]*>/g, '').trim())
+            safeText = '...';
         // Update timing BEFORE API call to prevent races
         this.lastEditTime = Date.now();
         try {
@@ -158,17 +183,20 @@ export class StreamAccumulator {
             }
         }
         catch (err) {
-            // Handle TG rate limit (429)
-            if (err && typeof err === 'object' && 'error_code' in err && err.error_code === 429) {
+            const errorCode = err && typeof err === 'object' && 'error_code' in err
+                ? err.error_code : 0;
+            // Handle TG rate limit (429) — retry
+            if (errorCode === 429) {
                 const retryAfter = err.parameters?.retry_after ?? 5;
                 this.editIntervalMs = Math.min(this.editIntervalMs * 2, 5000);
                 await sleep(retryAfter * 1000);
                 return this._doSendOrEdit(text);
             }
-            // Ignore "message is not modified" errors
+            // Ignore "message is not modified" errors (harmless)
             if (err instanceof Error && err.message.includes('message is not modified'))
                 return;
-            throw err;
+            // 400 (bad request), 403 (forbidden), and all other errors — log and skip, never throw
+            this.logger?.error?.({ err, errorCode }, 'Telegram API error in _doSendOrEdit — skipping');
         }
     }
     async sendImage() {
@@ -181,16 +209,149 @@ export class StreamAccumulator {
         }
         catch (err) {
             // Fall back to text indicator on failure
+            this.logger?.error?.({ err }, 'Failed to send image');
             this.buffer += '\n[Image could not be sent]';
         }
         this.imageBase64Buffer = '';
     }
-    async showToolIndicator(toolName) {
-        const bufferHtml = this.buffer ? makeHtmlSafe(this.buffer) : '';
-        const indicator = bufferHtml
-            ? `${bufferHtml}\n\n<i>Using ${escapeHtml(toolName)}...</i>`
-            : `<i>Using ${escapeHtml(toolName)}...</i>`;
-        await this.sendOrEdit(indicator, true);
+    /** Send an independent tool indicator message (not through the accumulator's sendOrEdit). */
+    async sendToolIndicator(blockId, toolName) {
+        const startTime = Date.now();
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                const html = `<blockquote expandable>⚡ ${escapeHtml(toolName)}…</blockquote>`;
+                const msgId = await this.sender.sendMessage(this.chatId, html, 'HTML');
+                this.toolMessages.set(blockId, { msgId, toolName, startTime });
+            }
+            catch (err) {
+                // Tool indicator is non-critical — log and continue
+                this.logger?.debug?.({ err, toolName }, 'Failed to send tool indicator');
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'sendToolIndicator queue error');
+        });
+        return this.sendQueue;
+    }
+    /** Update a tool indicator message with input preview once the JSON value is complete. */
+    toolIndicatorLastSummary = new Map(); // blockId → last rendered summary
+    async updateToolIndicatorWithInput(blockId) {
+        const entry = this.toolMessages.get(blockId);
+        if (!entry)
+            return;
+        const inputJson = this.toolInputBuffers.get(blockId) ?? '';
+        // Only extract from complete JSON (try parse succeeds) or complete regex match
+        // (the value must have a closing quote to avoid truncated paths)
+        const summary = extractToolInputSummary(entry.toolName, inputJson, 120, true);
+        if (!summary)
+            return; // not enough input yet or value still streaming
+        // Skip if summary hasn't changed since last edit
+        if (this.toolIndicatorLastSummary.get(blockId) === summary)
+            return;
+        this.toolIndicatorLastSummary.set(blockId, summary);
+        const codeLine = `\n<code>${escapeHtml(summary)}</code>`;
+        const html = `<blockquote expandable>⚡ ${escapeHtml(entry.toolName)}…${codeLine}</blockquote>`;
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                await this.sender.editMessage(this.chatId, entry.msgId, html, 'HTML');
+            }
+            catch (err) {
+                // "message is not modified" or other edit failure — non-critical
+                this.logger?.debug?.({ err }, 'Failed to update tool indicator with input');
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'updateToolIndicatorWithInput queue error');
+        });
+        return this.sendQueue;
+    }
+    /** Resolve a tool indicator with success/failure status. Edits to a compact summary with input detail. */
+    async resolveToolMessage(blockId, isError, errorMessage, resultContent, toolUseResult) {
+        const entry = this.toolMessages.get(blockId);
+        if (!entry)
+            return;
+        const { msgId, toolName, startTime } = entry;
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        const inputJson = this.toolInputBuffers.get(blockId) ?? '';
+        const summary = extractToolInputSummary(toolName, inputJson);
+        const resultStat = extractToolResultStat(toolName, resultContent, toolUseResult);
+        const codeLine = summary ? `\n<code>${escapeHtml(summary)}</code>` : '';
+        const statLine = resultStat ? `\n${escapeHtml(resultStat)}` : '';
+        const icon = isError ? '❌' : '✅';
+        const html = `<blockquote expandable>${icon} ${escapeHtml(toolName)} (${elapsed}s)${codeLine}${statLine}</blockquote>`;
+        // Clean up input buffer
+        this.toolInputBuffers.delete(blockId);
+        this.toolIndicatorLastSummary.delete(blockId);
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                await this.sender.editMessage(this.chatId, msgId, html, 'HTML');
+            }
+            catch (err) {
+                // Edit failure on resolve — non-critical
+                this.logger?.debug?.({ err, toolName }, 'Failed to resolve tool indicator');
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'resolveToolMessage queue error');
+        });
+        return this.sendQueue;
+    }
+    /** Edit a specific tool indicator message by block ID. */
+    async editToolMessage(blockId, html) {
+        const entry = this.toolMessages.get(blockId);
+        if (!entry)
+            return;
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                await this.sender.editMessage(this.chatId, entry.msgId, html, 'HTML');
+            }
+            catch (err) {
+                // Edit failure — non-critical
+                this.logger?.debug?.({ err }, 'Failed to edit tool message');
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'editToolMessage queue error');
+        });
+        return this.sendQueue;
+    }
+    /** Delete a specific tool indicator message by block ID. */
+    async deleteToolMessage(blockId) {
+        const entry = this.toolMessages.get(blockId);
+        if (!entry)
+            return;
+        this.toolMessages.delete(blockId);
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                if (this.sender.deleteMessage) {
+                    await this.sender.deleteMessage(this.chatId, entry.msgId);
+                }
+            }
+            catch (err) {
+                // Delete failure — non-critical
+                this.logger?.debug?.({ err }, 'Failed to delete tool message');
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'deleteToolMessage queue error');
+        });
+        return this.sendQueue;
+    }
+    /** Delete all tool indicator messages. */
+    async deleteAllToolMessages() {
+        const ids = [...this.toolMessages.values()];
+        this.toolMessages.clear();
+        if (!this.sender.deleteMessage)
+            return;
+        this.sendQueue = this.sendQueue.then(async () => {
+            for (const { msgId } of ids) {
+                try {
+                    await this.sender.deleteMessage(this.chatId, msgId);
+                }
+                catch (err) {
+                    // Delete failure — non-critical
+                    this.logger?.debug?.({ err }, 'Failed to delete tool message in batch');
+                }
+            }
+        }).catch(err => {
+            this.logger?.error?.({ err }, 'deleteAllToolMessages queue error');
+        });
+        return this.sendQueue;
     }
     async throttledEdit() {
         const now = Date.now();
@@ -301,24 +462,24 @@ export class StreamAccumulator {
             this.editTimer = null;
         }
     }
-    /** Soft reset: clear buffer/state but keep tgMessageId so next turn edits the same message */
+    /** Soft reset: clear buffer/state but keep tgMessageId so next turn edits the same message.
+     *  toolMessages persists across resets — they are independent of the text accumulator. */
     softReset() {
         this.buffer = '';
         this.thinkingBuffer = '';
         this.imageBase64Buffer = '';
         this.currentBlockType = null;
+        this.currentToolBlockId = null;
         this.lastEditTime = 0;
         this.thinkingIndicatorShown = false;
-        this.toolIndicators = [];
         this.finished = false;
         this.turnUsage = null;
-        this.clearEditTimer(); // Ensure cleanup
+        this.clearEditTimer();
     }
     /** Full reset: also clears tgMessageId (next send creates a new message).
-     *  Chains on the existing sendQueue so any pending finalize() edits complete first. */
+     *  Chains on the existing sendQueue so any pending finalize() edits complete first.
+     *  toolMessages persists — they are independent fire-and-forget messages. */
     reset() {
-        // Chain on the existing queue so pending sends (e.g. finalize) complete
-        // before the new turn starts sending.
         const prevQueue = this.sendQueue;
         this.softReset();
         this.tgMessageId = null;
@@ -327,6 +488,183 @@ export class StreamAccumulator {
     }
 }
 // ── Helpers ──
+/** Extract a human-readable summary from a tool's input JSON (may be partial/incomplete). */
+/** Shorten absolute paths to relative-ish display: /home/fonz/Botverse/KYO/src/foo.ts → KYO/src/foo.ts */
+function shortenPath(p) {
+    // Strip common prefixes
+    return p
+        .replace(/^\/home\/[^/]+\/Botverse\//, '')
+        .replace(/^\/home\/[^/]+\/Projects\//, '')
+        .replace(/^\/home\/[^/]+\//, '~/');
+}
+function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireComplete = false) {
+    if (!inputJson)
+        return null;
+    // Determine which field(s) to look for based on tool name
+    const fieldsByTool = {
+        Bash: ['command'],
+        Read: ['file_path', 'path'],
+        Write: ['file_path', 'path'],
+        Edit: ['file_path', 'path'],
+        MultiEdit: ['file_path', 'path'],
+        Search: ['pattern', 'query'],
+        Grep: ['pattern', 'query'],
+        Glob: ['pattern'],
+        TodoWrite: [], // handled specially below
+        TaskOutput: [], // handled specially below
+    };
+    const skipTools = new Set(['TodoRead']);
+    if (skipTools.has(toolName))
+        return null;
+    const fields = fieldsByTool[toolName];
+    const isPathTool = ['Read', 'Write', 'Edit', 'MultiEdit'].includes(toolName);
+    // Try parsing complete JSON first
+    try {
+        const parsed = JSON.parse(inputJson);
+        // TaskOutput: show task ID compactly
+        if (toolName === 'TaskOutput' && parsed.task_id) {
+            return `collecting result · ${String(parsed.task_id).slice(0, 7)}`;
+        }
+        // TodoWrite: show in-progress item or summary
+        if (toolName === 'TodoWrite' && Array.isArray(parsed.todos)) {
+            const todos = parsed.todos;
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            const item = inProgress ?? todos[todos.length - 1];
+            const total = todos.length;
+            const done = todos.filter(t => t.status === 'completed').length;
+            const label = item?.content?.trim() ?? '';
+            const prefix = `[${done}/${total}] `;
+            const combined = prefix + label;
+            return combined.length > maxLen ? combined.slice(0, maxLen) + '…' : combined;
+        }
+        if (fields) {
+            for (const f of fields) {
+                if (typeof parsed[f] === 'string' && parsed[f].trim()) {
+                    let val = parsed[f].trim();
+                    if (isPathTool)
+                        val = shortenPath(val);
+                    return val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
+                }
+            }
+        }
+        // Default: first string value
+        for (const val of Object.values(parsed)) {
+            if (typeof val === 'string' && val.trim()) {
+                const v = val.trim();
+                return v.length > maxLen ? v.slice(0, maxLen) + '…' : v;
+            }
+        }
+        return null;
+    }
+    catch {
+        if (requireComplete)
+            return null; // Only use fully-parsed JSON when requireComplete
+        // Partial JSON — regex extraction (only used for final resolve, not live preview)
+        const targetFields = fields ?? ['command', 'file_path', 'path', 'pattern', 'query'];
+        for (const key of targetFields) {
+            const re = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`, 'i'); // require closing quote
+            const m = inputJson.match(re);
+            if (m?.[1]) {
+                let val = m[1].replace(/\\n/g, ' ').replace(/\\t/g, '  ').replace(/\\"/g, '"');
+                if (isPathTool)
+                    val = shortenPath(val);
+                return val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
+            }
+        }
+        return null;
+    }
+}
+/** Extract a compact stat from a tool result for display in the indicator. */
+function extractToolResultStat(toolName, content, toolUseResult) {
+    // For Edit/Write: use structured patch data if available
+    if (toolUseResult && (toolName === 'Edit' || toolName === 'MultiEdit')) {
+        const patches = toolUseResult.structuredPatch;
+        if (patches?.length) {
+            let added = 0, removed = 0;
+            for (const patch of patches) {
+                if (patch.lines) {
+                    for (const line of patch.lines) {
+                        if (line.startsWith('+') && !line.startsWith('+++'))
+                            added++;
+                        else if (line.startsWith('-') && !line.startsWith('---'))
+                            removed++;
+                    }
+                }
+            }
+            if (added || removed) {
+                const parts = [];
+                if (added)
+                    parts.push(`+${added}`);
+                if (removed)
+                    parts.push(`-${removed}`);
+                return parts.join(' / ');
+            }
+        }
+    }
+    if (toolUseResult && toolName === 'Write') {
+        const c = toolUseResult.content;
+        if (c) {
+            const lines = c.split('\n').length;
+            return `${lines} lines`;
+        }
+    }
+    if (!content)
+        return '';
+    const first = content.split('\n')[0].trim();
+    // Skip generic "The file X has been updated/created" messages
+    if (/^(The file |File created|Successfully)/.test(first)) {
+        // Try to extract something useful anyway
+        const lines = content.match(/(\d+)\s*lines?/i);
+        if (lines)
+            return `${lines[1]} lines`;
+        return '';
+    }
+    switch (toolName) {
+        case 'Write': {
+            const lines = content.match(/(\d+)\s*lines?/i);
+            const bytes = content.match(/(\d[\d,.]*)\s*(bytes?|KB|MB)/i);
+            if (lines)
+                return `${lines[1]} lines`;
+            if (bytes)
+                return `${bytes[1]} ${bytes[2]}`;
+            return '';
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            const replaced = content.match(/replaced\s+(\d+)\s*lines?/i);
+            const chars = content.match(/(\d+)\s*characters?/i);
+            if (replaced)
+                return `${replaced[1]} lines replaced`;
+            if (chars)
+                return `${chars[1]} chars changed`;
+            return '';
+        }
+        case 'Bash': {
+            const exit = content.match(/exit\s*code\s*[:=]?\s*(\d+)/i);
+            if (exit && exit[1] !== '0')
+                return `exit ${exit[1]}`;
+            const outputLines = content.split('\n').filter(l => l.trim()).length;
+            if (outputLines > 3)
+                return `${outputLines} lines output`;
+            return first.length > 60 ? first.slice(0, 60) + '…' : first;
+        }
+        case 'Read': {
+            const lines = content.split('\n').length;
+            return `${lines} lines`;
+        }
+        case 'Search':
+        case 'Grep':
+        case 'Glob': {
+            const matches = content.match(/(\d+)\s*(match|result|file)/i);
+            if (matches)
+                return `${matches[1]} ${matches[2]}s`;
+            const resultLines = content.split('\n').filter(l => l.trim()).length;
+            return `${resultLines} results`;
+        }
+        default:
+            return '';
+    }
+}
 function findSplitPoint(text, threshold) {
     // Try to split at paragraph break
     const paragraphBreak = text.lastIndexOf('\n\n', threshold);
@@ -354,6 +692,8 @@ function formatTokens(n) {
 }
 /** Format usage stats as an HTML italic footer line */
 export function formatUsageFooter(usage) {
+    const totalCtx = usage.inputTokens + usage.cacheReadTokens + usage.cacheCreationTokens;
+    const ctxPct = Math.round(totalCtx / 200000 * 100);
     const parts = [
         `↩️ ${formatTokens(usage.inputTokens)} in`,
         `${formatTokens(usage.outputTokens)} out`,
@@ -361,6 +701,7 @@ export function formatUsageFooter(usage) {
     if (usage.costUsd != null) {
         parts.push(`$${usage.costUsd.toFixed(4)}`);
     }
+    parts.push(`${ctxPct}%`);
     return `<i>${parts.join(' · ')}</i>`;
 }
 // ── Sub-agent detection patterns ──
@@ -510,8 +851,10 @@ export class SubAgentTracker {
                 try {
                     await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
                 }
-                catch { /* ignore */ }
-            });
+                catch (err) {
+                    // Non-critical — edit failure on dispatched agent status
+                }
+            }).catch(() => { });
         }
     }
     async handleEvent(event) {
@@ -591,9 +934,9 @@ export class SubAgentTracker {
                 await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
             }
             catch {
-                // Ignore edit failures
+                // Edit failure on tool result — non-critical
             }
-        });
+        }).catch(() => { });
         await this.sendQueue;
     }
     async onBlockStart(event) {
@@ -630,9 +973,9 @@ export class SubAgentTracker {
                     this.consolidatedAgentMsgId = msgId;
                 }
                 catch {
-                    // Silently ignore
+                    // Sub-agent indicator is non-critical
                 }
-            });
+            }).catch(() => { });
             await this.sendQueue;
         }
     }
@@ -654,8 +997,10 @@ export class SubAgentTracker {
             try {
                 await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
             }
-            catch { /* ignore */ }
-        });
+            catch {
+                // Consolidated message edit failure — non-critical
+            }
+        }).catch(() => { });
     }
     async onInputDelta(event) {
         const toolUseId = this.blockToAgent.get(event.index);
@@ -797,8 +1142,10 @@ export class SubAgentTracker {
                 try {
                     await this.sender.setReaction?.(this.chatId, msgId, emoji);
                 }
-                catch { /* ignore — reaction might not be supported */ }
-            });
+                catch {
+                    // Reaction failure — non-critical, might not be supported
+                }
+            }).catch(() => { });
         }
         // Check if ALL dispatched agents are now completed
         if (this.onAllReported && !this.hasDispatchedAgents && this.agents.size > 0) {
@@ -890,8 +1237,10 @@ export class SubAgentTracker {
             try {
                 await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
             }
-            catch { /* ignore */ }
-        });
+            catch {
+                // Progress message edit failure — non-critical
+            }
+        }).catch(() => { });
     }
     /** Find a tracked sub-agent by tool_use_id. */
     getAgentByToolUseId(toolUseId) {