@fonz/tgcc 0.6.15 → 0.6.18

package/dist/streaming.js

@@ -10,6 +10,12 @@ export function escapeHtml(text) {
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 }
+/** Create visually distinct system message with enhanced styling */
+export function formatSystemMessage(type, content, expandable = false) {
+    const emoji = { thinking: '💭', tool: '⚡', usage: '📊', error: '⚠️', status: 'ℹ️' }[type];
+    const wrapper = expandable ? 'blockquote expandable' : 'blockquote';
+    return `<${wrapper}>${emoji} ${content}</${wrapper.split(' ')[0]}>`;
+}
 /**
  * Convert markdown text to Telegram-safe HTML using the marked library.
  * Replaces the old hand-rolled implementation with a proper markdown parser.
@@ -45,33 +51,59 @@ export class StreamAccumulator {
     lastEditTime = 0;
     editTimer = null;
     thinkingIndicatorShown = false;
+    thinkingMessageId = null; // preserved separately from tgMessageId
     messageIds = []; // all message IDs sent during this turn
     finished = false;
     sendQueue = Promise.resolve();
     turnUsage = null;
-    // Per-tool-use independent indicator messages (persists across resets)
+    /** Usage from the most recent message_start event — represents a single API call's context (not cumulative). */
+    _lastMsgStartCtx = null;
+    // Per-tool-use consolidated indicator message (persists across resets)
     toolMessages = new Map();
     toolInputBuffers = new Map(); // tool block ID → accumulated input JSON
     currentToolBlockId = null;
+    consolidatedToolMsgId = null; // shared TG message for all tool indicators
     constructor(options) {
         this.chatId = options.chatId;
         this.sender = options.sender;
         this.editIntervalMs = options.editIntervalMs ?? 1000;
-        this.splitThreshold = options.splitThreshold ?? 4000;
+        this.splitThreshold = options.splitThreshold ?? 3500;
         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) */
     setTurnUsage(usage) {
-        this.turnUsage = usage;
+        // Merge in per-API-call ctx tokens if we captured them from message_start events.
+        // These are bounded by the context window (unlike result event usage which accumulates across tool loops).
+        if (this._lastMsgStartCtx) {
+            this.turnUsage = {
+                ...usage,
+                ctxInputTokens: this._lastMsgStartCtx.input,
+                ctxCacheReadTokens: this._lastMsgStartCtx.cacheRead,
+                ctxCacheCreationTokens: this._lastMsgStartCtx.cacheCreation,
+            };
+        }
+        else {
+            this.turnUsage = usage;
+        }
     }
     // ── Process stream events ──
     async handleEvent(event) {
         switch (event.type) {
-            case 'message_start':
+            case 'message_start': {
                 // Bridge handles reset decision - no automatic reset here
+                // Capture per-API-call token counts for accurate context % (not cumulative like result event)
+                const msUsage = event.message?.usage;
+                if (msUsage) {
+                    this._lastMsgStartCtx = {
+                        input: msUsage.input_tokens ?? 0,
+                        cacheRead: msUsage.cache_read_input_tokens ?? 0,
+                        cacheCreation: msUsage.cache_creation_input_tokens ?? 0,
+                    };
+                }
                 break;
+            }
             case 'content_block_start':
                 await this.onContentBlockStart(event);
                 break;
@@ -98,23 +130,44 @@ export class StreamAccumulator {
         if (blockType === 'thinking') {
             this.currentBlockType = 'thinking';
             if (!this.thinkingIndicatorShown && !this.buffer) {
-                await this.sendOrEdit('<blockquote>💭 Thinking...</blockquote>', true);
+                await this.sendOrEdit(formatSystemMessage('thinking', 'Processing...'), true);
                 this.thinkingIndicatorShown = true;
             }
         }
         else if (blockType === 'text') {
             this.currentBlockType = 'text';
-            // Text always gets its own message — don't touch tool indicator messages
-            if (!this.tgMessageId) {
-                // Will create a new message on next sendOrEdit
+            // If thinking indicator was shown, update it with actual thinking content NOW
+            // (before text starts streaming below) — don't wait for finalize()
+            if (this.thinkingIndicatorShown && this.tgMessageId) {
+                this.thinkingMessageId = this.tgMessageId;
+                this.tgMessageId = null; // force new message for response text
+                // Flush "Processing..." → actual thinking content immediately
+                if (this.thinkingBuffer && this.thinkingMessageId) {
+                    const thinkingPreview = this.thinkingBuffer.length > 1024
+                        ? this.thinkingBuffer.slice(0, 1024) + '…'
+                        : this.thinkingBuffer;
+                    const html = formatSystemMessage('thinking', markdownToTelegramHtml(thinkingPreview), true);
+                    this.sendQueue = this.sendQueue.then(async () => {
+                        try {
+                            await this.sender.editMessage(this.chatId, this.thinkingMessageId, html, 'HTML');
+                        }
+                        catch {
+                            // Non-critical — thinking message update
+                        }
+                    }).catch(err => {
+                        this.logger?.error?.({ err }, 'Failed to flush thinking indicator');
+                    });
+                }
             }
         }
         else if (blockType === 'tool_use') {
             this.currentBlockType = 'tool_use';
             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);
+            // Sub-agent tools are handled by SubAgentTracker — skip duplicate indicator
+            if (!isSubAgentTool(block.name)) {
+                await this.sendToolIndicator(block.id, block.name);
+            }
         }
         else if (blockType === 'image') {
             this.currentBlockType = 'image';
@@ -214,23 +267,74 @@ export class StreamAccumulator {
         }
         this.imageBase64Buffer = '';
     }
-    /** Send an independent tool indicator message (not through the accumulator's sendOrEdit). */
+    /** Send or update the consolidated tool indicator message. */
     async sendToolIndicator(blockId, toolName) {
         const startTime = Date.now();
+        if (this.consolidatedToolMsgId) {
+            // Reuse existing consolidated message
+            this.toolMessages.set(blockId, { msgId: this.consolidatedToolMsgId, toolName, startTime, resolved: false, isError: false, elapsed: null });
+            this.updateConsolidatedToolMessage();
+        }
+        else {
+            // Create the first consolidated tool message
+            this.sendQueue = this.sendQueue.then(async () => {
+                try {
+                    const html = this.buildConsolidatedToolHtml(blockId, toolName);
+                    const msgId = await this.sender.sendMessage(this.chatId, html, 'HTML');
+                    this.consolidatedToolMsgId = msgId;
+                    this.toolMessages.set(blockId, { msgId, toolName, startTime, resolved: false, isError: false, elapsed: null });
+                }
+                catch (err) {
+                    this.logger?.debug?.({ err, toolName }, 'Failed to send tool indicator');
+                }
+            }).catch(err => {
+                this.logger?.error?.({ err }, 'sendToolIndicator queue error');
+            });
+            return this.sendQueue;
+        }
+    }
+    /** Build HTML for the consolidated tool indicator message. */
+    buildConsolidatedToolHtml(pendingBlockId, pendingToolName) {
+        const lines = [];
+        for (const [blockId, entry] of this.toolMessages) {
+            const summary = this.toolIndicatorLastSummary.get(blockId);
+            const codePart = summary ? ` · <code>${escapeHtml(summary)}</code>` : '';
+            if (entry.resolved) {
+                const statLine = this.toolResolvedStats.get(blockId);
+                const statPart = statLine ? ` · ${escapeHtml(statLine)}` : '';
+                const icon = entry.isError ? '❌' : '✅';
+                lines.push(`${icon} ${escapeHtml(entry.toolName)} (${entry.elapsed})${codePart}${statPart}`);
+            }
+            else {
+                lines.push(`⚡ ${escapeHtml(entry.toolName)}…${codePart}`);
+            }
+        }
+        // Include pending tool that hasn't been added to toolMessages yet
+        if (pendingBlockId && pendingToolName && !this.toolMessages.has(pendingBlockId)) {
+            lines.push(`⚡ ${escapeHtml(pendingToolName)}…`);
+        }
+        return `<blockquote expandable>${lines.join('\n')}</blockquote>`;
+    }
+    /** Resolved tool result stats, keyed by blockId */
+    toolResolvedStats = new Map();
+    /** Edit the consolidated tool message with current state of all tools. */
+    updateConsolidatedToolMessage() {
+        if (!this.consolidatedToolMsgId)
+            return;
+        const msgId = this.consolidatedToolMsgId;
+        const html = this.buildConsolidatedToolHtml();
         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 });
+                await this.sender.editMessage(this.chatId, msgId, html, 'HTML');
             }
             catch (err) {
-                // Tool indicator is non-critical — log and continue
-                this.logger?.debug?.({ err, toolName }, 'Failed to send tool indicator');
+                if (err instanceof Error && err.message.includes('message is not modified'))
+                    return;
+                this.logger?.debug?.({ err }, 'Failed to update consolidated tool message');
             }
         }).catch(err => {
-            this.logger?.error?.({ err }, 'sendToolIndicator queue error');
+            this.logger?.error?.({ err }, 'updateConsolidatedToolMessage 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
@@ -248,105 +352,118 @@ export class StreamAccumulator {
         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;
+        // Update the consolidated tool message
+        this.updateConsolidatedToolMessage();
     }
-    /** Resolve a tool indicator with success/failure status. Edits to a compact summary with input detail. */
+    /** MCP media tools — on success, delete indicator (the media was sent directly). On failure, keep + react ❌. */
+    static MCP_MEDIA_TOOLS = new Set(['mcp__tgcc__send_image', 'mcp__tgcc__send_file', 'mcp__tgcc__send_voice']);
+    /** Resolve a tool indicator with success/failure status. Updates the consolidated message. */
     async resolveToolMessage(blockId, isError, errorMessage, resultContent, toolUseResult) {
         const entry = this.toolMessages.get(blockId);
         if (!entry)
             return;
-        const { msgId, toolName, startTime } = entry;
+        const { toolName, startTime } = entry;
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        // MCP media tools: remove from consolidated on success (the media itself is the result)
+        if (StreamAccumulator.MCP_MEDIA_TOOLS.has(toolName) && !isError) {
+            this.toolInputBuffers.delete(blockId);
+            this.toolIndicatorLastSummary.delete(blockId);
+            this.toolResolvedStats.delete(blockId);
+            this.toolMessages.delete(blockId);
+            // If that was the only tool, delete the consolidated message
+            if (this.toolMessages.size === 0 && this.consolidatedToolMsgId) {
+                const msgId = this.consolidatedToolMsgId;
+                this.consolidatedToolMsgId = null;
+                this.sendQueue = this.sendQueue.then(async () => {
+                    try {
+                        if (this.sender.deleteMessage)
+                            await this.sender.deleteMessage(this.chatId, msgId);
+                    }
+                    catch (err) {
+                        this.logger?.debug?.({ err, toolName }, 'Failed to delete consolidated tool message');
+                    }
+                }).catch(err => {
+                    this.logger?.error?.({ err }, 'resolveToolMessage queue error');
+                });
+            }
+            else {
+                this.updateConsolidatedToolMessage();
+            }
+            return;
+        }
+        // Compute final input summary if we don't have one yet
         const inputJson = this.toolInputBuffers.get(blockId) ?? '';
-        const summary = extractToolInputSummary(toolName, inputJson);
+        if (!this.toolIndicatorLastSummary.has(blockId)) {
+            const summary = extractToolInputSummary(toolName, inputJson);
+            if (summary)
+                this.toolIndicatorLastSummary.set(blockId, summary);
+        }
+        // Store result stat for display
         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>`;
+        if (resultStat)
+            this.toolResolvedStats.set(blockId, resultStat);
+        // Mark as resolved
+        entry.resolved = true;
+        entry.isError = isError;
+        entry.elapsed = elapsed + 's';
         // 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;
+        // Update the consolidated message
+        this.updateConsolidatedToolMessage();
     }
-    /** Edit a specific tool indicator message by block ID. */
-    async editToolMessage(blockId, html) {
-        const entry = this.toolMessages.get(blockId);
-        if (!entry)
+    /** Edit a specific tool indicator message by block ID (updates the consolidated message). */
+    async editToolMessage(blockId, _html) {
+        if (!this.toolMessages.has(blockId))
             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;
+        // With consolidation, just rebuild the consolidated message
+        this.updateConsolidatedToolMessage();
     }
-    /** Delete a specific tool indicator message by block ID. */
+    /** Delete a specific tool from the consolidated indicator. */
     async deleteToolMessage(blockId) {
-        const entry = this.toolMessages.get(blockId);
-        if (!entry)
+        if (!this.toolMessages.has(blockId))
             return;
         this.toolMessages.delete(blockId);
-        this.sendQueue = this.sendQueue.then(async () => {
-            try {
-                if (this.sender.deleteMessage) {
-                    await this.sender.deleteMessage(this.chatId, entry.msgId);
+        this.toolInputBuffers.delete(blockId);
+        this.toolIndicatorLastSummary.delete(blockId);
+        this.toolResolvedStats.delete(blockId);
+        if (this.toolMessages.size === 0 && this.consolidatedToolMsgId) {
+            // Last tool removed — delete the consolidated message
+            const msgId = this.consolidatedToolMsgId;
+            this.consolidatedToolMsgId = null;
+            this.sendQueue = this.sendQueue.then(async () => {
+                try {
+                    if (this.sender.deleteMessage)
+                        await this.sender.deleteMessage(this.chatId, 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;
+                catch (err) {
+                    this.logger?.debug?.({ err }, 'Failed to delete consolidated tool message');
+                }
+            }).catch(err => {
+                this.logger?.error?.({ err }, 'deleteToolMessage queue error');
+            });
+        }
+        else {
+            this.updateConsolidatedToolMessage();
+        }
     }
-    /** Delete all tool indicator messages. */
+    /** Delete the consolidated tool indicator message. */
     async deleteAllToolMessages() {
-        const ids = [...this.toolMessages.values()];
         this.toolMessages.clear();
-        if (!this.sender.deleteMessage)
+        this.toolInputBuffers.clear();
+        this.toolIndicatorLastSummary.clear();
+        this.toolResolvedStats.clear();
+        if (!this.consolidatedToolMsgId || !this.sender.deleteMessage) {
+            this.consolidatedToolMsgId = null;
             return;
+        }
+        const msgId = this.consolidatedToolMsgId;
+        this.consolidatedToolMsgId = null;
         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');
-                }
+            try {
+                await this.sender.deleteMessage(this.chatId, msgId);
+            }
+            catch (err) {
+                this.logger?.debug?.({ err }, 'Failed to delete consolidated tool message');
             }
         }).catch(err => {
             this.logger?.error?.({ err }, 'deleteAllToolMessages queue error');
@@ -377,16 +494,19 @@ export class StreamAccumulator {
      */
     buildFullText(includeSuffix = false) {
         let text = '';
-        if (this.thinkingBuffer) {
+        // Thinking goes in its own message (thinkingMessageId), not prepended to response
+        if (this.thinkingBuffer && !this.thinkingMessageId) {
+            // Only prepend if thinking didn't get its own message (edge case: no indicator was shown)
             const thinkingPreview = this.thinkingBuffer.length > 1024
                 ? this.thinkingBuffer.slice(0, 1024) + '…'
                 : this.thinkingBuffer;
-            text += `<blockquote expandable>💭 Thinking\n${markdownToTelegramHtml(thinkingPreview)}</blockquote>\n`;
+            text += formatSystemMessage('thinking', markdownToTelegramHtml(thinkingPreview), true) + '\n';
         }
         // Convert markdown buffer to HTML-safe text
         text += makeHtmlSafe(this.buffer);
         if (includeSuffix && this.turnUsage) {
-            text += '\n' + formatUsageFooter(this.turnUsage);
+            const usageContent = formatUsageFooter(this.turnUsage, this.turnUsage.model).replace(/<\/?i>/g, '');
+            text += '\n' + formatSystemMessage('usage', usageContent);
         }
         return { text, hasHtmlSuffix: includeSuffix && !!this.turnUsage };
     }
@@ -443,17 +563,29 @@ export class StreamAccumulator {
             clearTimeout(this.editTimer);
             this.editTimer = null;
         }
+        // Update thinking message with final content (if it has its own message)
+        if (this.thinkingBuffer && this.thinkingMessageId) {
+            const thinkingPreview = this.thinkingBuffer.length > 1024
+                ? this.thinkingBuffer.slice(0, 1024) + '…'
+                : this.thinkingBuffer;
+            try {
+                await this.sender.editMessage(this.chatId, this.thinkingMessageId, formatSystemMessage('thinking', markdownToTelegramHtml(thinkingPreview), true), 'HTML');
+            }
+            catch {
+                // Thinking message edit failed — not critical
+            }
+        }
         if (this.buffer) {
-            // Final edit with complete text including thinking blockquote and usage footer
+            // Final edit with complete text (thinking is in its own message)
             const { text } = this.buildFullText(true);
             await this.sendOrEdit(text, true); // buildFullText already does makeHtmlSafe
         }
-        else if (this.thinkingBuffer && this.thinkingIndicatorShown) {
-            // Only thinking happened, no text — show thinking as expandable blockquote
+        else if (this.thinkingBuffer && !this.thinkingMessageId && this.thinkingIndicatorShown) {
+            // Only thinking happened, no text, no separate message — show as expandable blockquote
             const thinkingPreview = this.thinkingBuffer.length > 1024
                 ? this.thinkingBuffer.slice(0, 1024) + '…'
                 : this.thinkingBuffer;
-            await this.sendOrEdit(`<blockquote expandable>💭 Thinking\n${markdownToTelegramHtml(thinkingPreview)}</blockquote>`, true);
+            await this.sendOrEdit(formatSystemMessage('thinking', markdownToTelegramHtml(thinkingPreview), true), true);
         }
     }
     clearEditTimer() {
@@ -472,18 +604,26 @@ export class StreamAccumulator {
         this.currentToolBlockId = null;
         this.lastEditTime = 0;
         this.thinkingIndicatorShown = false;
+        this.thinkingMessageId = null;
         this.finished = false;
         this.turnUsage = null;
+        this._lastMsgStartCtx = null;
         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.
-     *  toolMessages persists — they are independent fire-and-forget messages. */
+     *  Consolidated tool message resets so next turn starts a fresh batch. */
     reset() {
         const prevQueue = this.sendQueue;
         this.softReset();
         this.tgMessageId = null;
         this.messageIds = [];
+        // Reset tool consolidation for next turn
+        this.consolidatedToolMsgId = null;
+        this.toolMessages.clear();
+        this.toolInputBuffers.clear();
+        this.toolIndicatorLastSummary.clear();
+        this.toolResolvedStats.clear();
         this.sendQueue = prevQueue.catch(() => { }); // swallow errors from prev turn
     }
 }
@@ -691,17 +831,24 @@ function formatTokens(n) {
     return String(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);
+export function formatUsageFooter(usage, _model) {
+    // Use per-API-call ctx tokens (from message_start) for context % — these are bounded by the
+    // context window. Fall back to cumulative result event tokens only if ctx tokens unavailable.
+    const ctxInput = usage.ctxInputTokens ?? usage.inputTokens;
+    const ctxRead = usage.ctxCacheReadTokens ?? usage.cacheReadTokens;
+    const ctxCreation = usage.ctxCacheCreationTokens ?? usage.cacheCreationTokens;
+    const totalCtx = ctxInput + ctxRead + ctxCreation;
+    const CONTEXT_WINDOW = 200_000;
+    const ctxPct = Math.round(totalCtx / CONTEXT_WINDOW * 100);
+    const overLimit = ctxPct > 90;
     const parts = [
-        `↩️ ${formatTokens(usage.inputTokens)} in`,
+        `${formatTokens(usage.inputTokens)} in`,
         `${formatTokens(usage.outputTokens)} out`,
     ];
     if (usage.costUsd != null) {
         parts.push(`$${usage.costUsd.toFixed(4)}`);
     }
-    parts.push(`${ctxPct}%`);
+    parts.push(overLimit ? `⚠️ ${ctxPct}%` : `${ctxPct}%`);
     return `<i>${parts.join(' · ')}</i>`;
 }
 // ── Sub-agent detection patterns ──
@@ -846,10 +993,12 @@ export class SubAgentTracker {
                 continue;
             info.status = 'completed';
             const label = info.label || info.toolName;
-            const text = `✅ ${escapeHtml(label)} — see main message`;
+            const text = `<blockquote>🤖 ${escapeHtml(label)} — see main message</blockquote>`;
+            const agentMsgId = info.tgMessageId;
             this.sendQueue = this.sendQueue.then(async () => {
                 try {
-                    await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
+                    await this.sender.editMessage(this.chatId, agentMsgId, text, 'HTML');
+                    await this.sender.setReaction?.(this.chatId, agentMsgId, '👍');
                 }
                 catch (err) {
                     // Non-critical — edit failure on dispatched agent status
@@ -924,14 +1073,17 @@ export class SubAgentTracker {
             return;
         info.status = 'completed';
         const label = info.label || info.toolName;
-        // Truncate result for blockquote (TG message limit ~4096 chars)
         const maxResultLen = 3500;
         const resultText = result.length > maxResultLen ? result.slice(0, maxResultLen) + '…' : result;
-        // Use expandable blockquote — collapsed shows "✅ label" + first line, tap to expand
-        const text = `<blockquote expandable>✅ ${escapeHtml(label)}\n${escapeHtml(resultText)}</blockquote>`;
+        // Blockquote header + expandable result (not nested — TG doesn't support nested blockquotes)
+        const text = `<blockquote>🤖 ${escapeHtml(label)}</blockquote>\n<blockquote expandable>${escapeHtml(resultText)}</blockquote>`;
+        const msgId = info.tgMessageId;
         this.sendQueue = this.sendQueue.then(async () => {
             try {
-                await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
+                await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
+                if (this.sender.setReaction) {
+                    await this.sender.setReaction(this.chatId, msgId, '👍');
+                }
             }
             catch {
                 // Edit failure on tool result — non-critical
@@ -968,7 +1120,7 @@ export class SubAgentTracker {
         else {
             this.sendQueue = this.sendQueue.then(async () => {
                 try {
-                    const msgId = await this.sender.sendMessage(this.chatId, '🤖 Starting sub-agent…', 'HTML');
+                    const msgId = await this.sender.sendMessage(this.chatId, '<blockquote>🤖 Starting sub-agent…</blockquote>', 'HTML');
                     info.tgMessageId = msgId;
                     this.consolidatedAgentMsgId = msgId;
                 }
@@ -992,7 +1144,7 @@ export class SubAgentTracker {
                     : 'Working…';
             lines.push(`🤖 ${escapeHtml(label)} — ${status}`);
         }
-        const text = lines.join('\n');
+        const text = `<blockquote>${lines.join('\n')}</blockquote>`;
         this.sendQueue = this.sendQueue.then(async () => {
             try {
                 await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
@@ -1232,7 +1384,7 @@ export class SubAgentTracker {
                 lines.push(`🤖 ${escapeHtml(label)} — ${status}`);
             }
         }
-        const text = lines.join('\n');
+        const text = `<blockquote>${lines.join('\n')}</blockquote>`;
         this.sendQueue = this.sendQueue.then(async () => {
             try {
                 await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
@@ -1263,7 +1415,7 @@ export class SubAgentTracker {
     }
 }
 // ── Utility: split a completed text into TG-sized chunks ──
-export function splitText(text, maxLength = 4000) {
+export function splitText(text, maxLength = 3500) {
     if (text.length <= maxLength)
         return [text];
     const chunks = [];