@fonz/tgcc 0.6.12 → 0.6.14

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) {
+        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 = resultContent ? extractToolResultStat(toolName, resultContent) : '';
+        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,130 @@ 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: ['content', 'task', 'text'],
+    };
+    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);
+        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) {
+    if (!content)
+        return '';
+    const first = content.split('\n')[0].trim();
+    switch (toolName) {
+        case 'Write': {
+            // "Successfully wrote 42 lines to src/foo.ts" or byte count
+            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 first.length > 60 ? first.slice(0, 60) + '…' : first;
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            // "Edited src/foo.ts: replaced 3 lines" or snippet
+            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 first.length > 60 ? first.slice(0, 60) + '…' : first;
+        }
+        case 'Bash': {
+            // Show exit code or first line of output (truncated)
+            const exit = content.match(/exit\s*code\s*[:=]?\s*(\d+)/i);
+            if (exit && exit[1] !== '0')
+                return `exit ${exit[1]}`;
+            // Count output lines
+            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 first.length > 60 ? first.slice(0, 60) + '…' : first;
+    }
+}
 function findSplitPoint(text, threshold) {
     // Try to split at paragraph break
     const paragraphBreak = text.lastIndexOf('\n\n', threshold);
@@ -397,36 +682,46 @@ export function extractSubAgentSummary(jsonInput, maxLen = 150) {
     }
     return '';
 }
+/** Label fields in priority order (index 0 = highest priority). */
+const LABEL_FIELDS = ['name', 'description', 'subagent_type', 'team_name'];
+/** Priority index for a label source field. Lower = better. */
+export function labelFieldPriority(field) {
+    if (!field)
+        return LABEL_FIELDS.length + 1; // worst
+    const idx = LABEL_FIELDS.indexOf(field);
+    return idx >= 0 ? idx : LABEL_FIELDS.length;
+}
 /**
  * Extract a human-readable label for a sub-agent from its JSON tool input.
- * Uses CC's Task tool structured fields: name, description, subagent_type, team_name.
- * No regex guessing — purely structural JSON field extraction.
+ * Returns { label, field } so callers can track priority and upgrade labels
+ * when higher-priority fields become available during streaming.
  */
 export function extractAgentLabel(jsonInput) {
-    // Priority order of CC Task tool fields
-    const labelFields = ['name', 'description', 'subagent_type', 'team_name'];
     const summaryField = 'prompt'; // last resort — first line of prompt
     try {
         const parsed = JSON.parse(jsonInput);
-        for (const key of labelFields) {
+        for (const key of LABEL_FIELDS) {
             const val = parsed[key];
             if (typeof val === 'string' && val.trim()) {
-                return val.trim().slice(0, 80);
+                return { label: val.trim().slice(0, 80), field: key };
             }
         }
         if (typeof parsed[summaryField] === 'string' && parsed[summaryField].trim()) {
             const firstLine = parsed[summaryField].trim().split('\n')[0];
-            return firstLine.length > 60 ? firstLine.slice(0, 60) + '…' : firstLine;
+            const label = firstLine.length > 60 ? firstLine.slice(0, 60) + '…' : firstLine;
+            return { label, field: 'prompt' };
         }
-        return '';
+        return { label: '', field: null };
     }
     catch {
         // JSON incomplete during streaming — extract first complete field value
-        return extractFieldFromPartialJson(jsonInput, labelFields) ?? '';
+        const result = extractFieldFromPartialJsonWithField(jsonInput, LABEL_FIELDS);
+        return result ?? { label: '', field: null };
     }
 }
-/** Extract the first complete string value for any of the given keys from partial JSON. */
-function extractFieldFromPartialJson(input, keys) {
+/** Extract the first complete string value for any of the given keys from partial JSON.
+ *  Returns { label, field } so callers know which field matched. */
+function extractFieldFromPartialJsonWithField(input, keys) {
     for (const key of keys) {
         const idx = input.indexOf(`"${key}"`);
         if (idx === -1)
@@ -447,7 +742,7 @@ function extractFieldFromPartialJson(input, keys) {
             }
             else if (afterColon[i] === '"') {
                 if (value.trim())
-                    return value.trim().slice(0, 80);
+                    return { label: value.trim().slice(0, 80), field: key };
                 break;
             }
             else {
@@ -500,8 +795,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) {
@@ -581,9 +878,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) {
@@ -599,6 +896,7 @@ export class SubAgentTracker {
             tgMessageId: null,
             status: 'running',
             label: '',
+            labelField: null,
             agentName: '',
             inputPreview: '',
             dispatchedAt: null,
@@ -619,9 +917,9 @@ export class SubAgentTracker {
                     this.consolidatedAgentMsgId = msgId;
                 }
                 catch {
-                    // Silently ignore
+                    // Sub-agent indicator is non-critical
                 }
-            });
+            }).catch(() => { });
             await this.sendQueue;
         }
     }
@@ -643,8 +941,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);
@@ -671,13 +971,13 @@ export class SubAgentTracker {
                     info.agentName = nameMatch[1];
             }
         }
-        // Try to extract an agent label
-        if (!info.label) {
-            const label = extractAgentLabel(info.inputPreview);
-            if (label) {
-                info.label = label;
-                this.updateConsolidatedAgentMessage();
-            }
+        // Try to extract an agent label — keep trying for higher-priority fields
+        // (e.g., upgrade from subagent_type "general-purpose" to description "Fix the bug")
+        const extracted = extractAgentLabel(info.inputPreview);
+        if (extracted.label && labelFieldPriority(extracted.field) < labelFieldPriority(info.labelField)) {
+            info.label = extracted.label;
+            info.labelField = extracted.field;
+            this.updateConsolidatedAgentMessage();
         }
     }
     async onBlockStop(event) {
@@ -690,11 +990,11 @@ export class SubAgentTracker {
         // content_block_stop = input done, NOT sub-agent done. Mark as dispatched.
         info.status = 'dispatched';
         info.dispatchedAt = Date.now();
-        // Final chance to extract label from complete input
-        if (!info.label) {
-            const label = extractAgentLabel(info.inputPreview);
-            if (label)
-                info.label = label;
+        // Final chance to extract label from complete input (may upgrade to higher-priority field)
+        const finalExtracted = extractAgentLabel(info.inputPreview);
+        if (finalExtracted.label && labelFieldPriority(finalExtracted.field) < labelFieldPriority(info.labelField)) {
+            info.label = finalExtracted.label;
+            info.labelField = finalExtracted.field;
         }
         this.updateConsolidatedAgentMessage();
         // Start elapsed timer — update every 15s to show progress
@@ -786,8 +1086,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) {
@@ -815,6 +1117,79 @@ export class SubAgentTracker {
         }
         return null;
     }
+    /** Handle a system task_started event — update the sub-agent status display. */
+    handleTaskStarted(toolUseId, description, taskType) {
+        const info = this.agents.get(toolUseId);
+        if (!info)
+            return;
+        // Use task_started description as label if we don't have one yet or current is low-priority
+        if (description && labelFieldPriority('description') < labelFieldPriority(info.labelField)) {
+            info.label = description.slice(0, 80);
+            info.labelField = 'description';
+        }
+        info.status = 'dispatched';
+        if (!info.dispatchedAt)
+            info.dispatchedAt = Date.now();
+        this.updateConsolidatedAgentMessage();
+    }
+    /** Handle a system task_progress event — update the sub-agent status with current activity. */
+    handleTaskProgress(toolUseId, description, lastToolName) {
+        const info = this.agents.get(toolUseId);
+        if (!info)
+            return;
+        if (info.status === 'completed')
+            return; // Don't update completed agents
+        // Update the consolidated message with progress info
+        this.updateConsolidatedAgentMessageWithProgress(toolUseId, description, lastToolName);
+    }
+    /** Handle a system task_completed event. */
+    handleTaskCompleted(toolUseId) {
+        const info = this.agents.get(toolUseId);
+        if (!info || info.status === 'completed')
+            return;
+        info.status = 'completed';
+        this.updateConsolidatedAgentMessage();
+        // Check if all agents are done
+        const allDone = ![...this.agents.values()].some(a => a.status === 'dispatched');
+        if (allDone && this.onAllReported) {
+            this.onAllReported();
+            this.stopMailboxWatch();
+        }
+    }
+    /** Build and edit the shared sub-agent status message with progress info. */
+    updateConsolidatedAgentMessageWithProgress(progressToolUseId, progressDesc, lastTool) {
+        if (!this.consolidatedAgentMsgId)
+            return;
+        const msgId = this.consolidatedAgentMsgId;
+        const lines = [];
+        for (const info of this.agents.values()) {
+            const label = info.label || info.agentName || info.toolName;
+            if (info.toolUseId === progressToolUseId && info.status !== 'completed') {
+                const toolInfo = lastTool ? ` (${lastTool})` : '';
+                const desc = progressDesc ? `: ${progressDesc.slice(0, 60)}` : '';
+                lines.push(`🤖 ${escapeHtml(label)} — Working${toolInfo}${desc}`);
+            }
+            else {
+                const status = info.status === 'completed' ? '✅ Done'
+                    : info.status === 'dispatched' ? 'Waiting for results…'
+                        : 'Working…';
+                lines.push(`🤖 ${escapeHtml(label)} — ${status}`);
+            }
+        }
+        const text = lines.join('\n');
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
+            }
+            catch {
+                // Progress message edit failure — non-critical
+            }
+        }).catch(() => { });
+    }
+    /** Find a tracked sub-agent by tool_use_id. */
+    getAgentByToolUseId(toolUseId) {
+        return this.agents.get(toolUseId);
+    }
     reset() {
         // Stop mailbox watching
         this.stopMailboxWatch();