@fonz/tgcc 0.2.0 → 0.4.0

package/dist/streaming.js

@@ -1,3 +1,7 @@
+import { readFileSync, watchFile, unwatchFile, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { markdownToTelegramHtml } from './telegram-html.js';
 // ── HTML safety & conversion ──
 /** Escape characters that are special in Telegram HTML. */
 export function escapeHtml(text) {
@@ -7,43 +11,11 @@ export function escapeHtml(text) {
         .replace(/>/g, '>');
 }
 /**
- * Convert markdown-ish text to Telegram-safe HTML.
- * Handles code blocks, inline code, bold, italic, strikethrough, links.
- * Falls back to HTML-escaped plain text for anything it can't convert.
+ * Convert markdown text to Telegram-safe HTML using the marked library.
+ * Replaces the old hand-rolled implementation with a proper markdown parser.
  */
 export function markdownToHtml(text) {
-    // First, extract code blocks to protect them from other conversions
-    const codeBlocks = [];
-    let result = text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, lang, code) => {
-        const idx = codeBlocks.length;
-        const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : '';
-        codeBlocks.push(`<pre><code${langAttr}>${escapeHtml(code.replace(/\n$/, ''))}</code></pre>`);
-        return `\x00CODEBLOCK${idx}\x00`;
-    });
-    // Extract inline code
-    const inlineCodes = [];
-    result = result.replace(/`([^`\n]+)`/g, (_match, code) => {
-        const idx = inlineCodes.length;
-        inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
-        return `\x00INLINE${idx}\x00`;
-    });
-    // Escape HTML in remaining text
-    result = escapeHtml(result);
-    // Convert markdown formatting
-    // Bold: **text** or __text__
-    result = result.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
-    result = result.replace(/__(.+?)__/g, '<b>$1</b>');
-    // Italic: *text* or _text_ (but not inside words for underscore)
-    result = result.replace(/(?<!\w)\*([^*\n]+?)\*(?!\w)/g, '<i>$1</i>');
-    result = result.replace(/(?<!\w)_([^_\n]+?)_(?!\w)/g, '<i>$1</i>');
-    // Strikethrough: ~~text~~
-    result = result.replace(/~~(.+?)~~/g, '<s>$1</s>');
-    // Links: [text](url)
-    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-    // Restore code blocks and inline code
-    result = result.replace(/\x00CODEBLOCK(\d+)\x00/g, (_match, idx) => codeBlocks[Number(idx)]);
-    result = result.replace(/\x00INLINE(\d+)\x00/g, (_match, idx) => inlineCodes[Number(idx)]);
-    return result;
+    return markdownToTelegramHtml(text);
 }
 /**
  * Make text safe for Telegram HTML parse mode during streaming.
@@ -91,8 +63,7 @@ export class StreamAccumulator {
     async handleEvent(event) {
         switch (event.type) {
             case 'message_start':
-                // New assistant turn — reset buffer but keep tgMessageId to edit same message
-                this.softReset();
+                // Bridge handles reset decision - no automatic reset here
                 break;
             case 'content_block_start':
                 await this.onContentBlockStart(event);
@@ -170,6 +141,8 @@ export class StreamAccumulator {
     }
     async _doSendOrEdit(text, rawHtml = false) {
         const safeText = (rawHtml ? text : makeHtmlSafe(text)) || '...';
+        // Update timing BEFORE API call to prevent races
+        this.lastEditTime = Date.now();
         try {
             if (!this.tgMessageId) {
                 this.tgMessageId = await this.sender.sendMessage(this.chatId, safeText, 'HTML');
@@ -178,7 +151,6 @@ export class StreamAccumulator {
             else {
                 await this.sender.editMessage(this.chatId, this.tgMessageId, safeText, 'HTML');
             }
-            this.lastEditTime = Date.now();
         }
         catch (err) {
             // Handle TG rate limit (429)
@@ -233,32 +205,35 @@ export class StreamAccumulator {
             }, delay);
         }
     }
-    /** Build the full message text including thinking blockquote prefix and usage footer */
+    /** Build the full message text including thinking blockquote prefix and usage footer.
+     *  Returns { text, hasHtmlSuffix } — caller must pass rawHtml=true when hasHtmlSuffix is set
+     *  because the footer contains pre-formatted HTML (<i> tags).
+     */
     buildFullText(includeSuffix = false) {
         let text = '';
         if (this.thinkingBuffer) {
-            // Truncate thinking to 1024 chars max for the expandable blockquote
             const thinkingPreview = this.thinkingBuffer.length > 1024
                 ? this.thinkingBuffer.slice(0, 1024) + '…'
                 : this.thinkingBuffer;
             text += `<blockquote expandable>💭 Thinking\n${escapeHtml(thinkingPreview)}</blockquote>\n`;
         }
-        text += this.buffer;
+        // Convert markdown buffer to HTML-safe text
+        text += makeHtmlSafe(this.buffer);
         if (includeSuffix && this.turnUsage) {
             text += '\n' + formatUsageFooter(this.turnUsage);
         }
-        return text;
+        return { text, hasHtmlSuffix: includeSuffix && !!this.turnUsage };
     }
     async doEdit() {
         if (!this.buffer)
             return;
-        const fullText = this.buildFullText();
+        const { text, hasHtmlSuffix } = this.buildFullText();
         // Check if we need to split
-        if (fullText.length > this.splitThreshold) {
+        if (text.length > this.splitThreshold) {
             await this.splitMessage();
             return;
         }
-        await this.sendOrEdit(fullText);
+        await this.sendOrEdit(text, true); // buildFullText already does makeHtmlSafe
     }
     async splitMessage() {
         // Find a good split point near the threshold
@@ -266,12 +241,12 @@ export class StreamAccumulator {
         const firstPart = this.buffer.slice(0, splitAt);
         const remainder = this.buffer.slice(splitAt);
         // Finalize current message with first part
-        await this.sendOrEdit(firstPart);
+        await this.sendOrEdit(makeHtmlSafe(firstPart), true);
         // Start a new message for remainder
         this.tgMessageId = null;
         this.buffer = remainder;
         if (this.buffer) {
-            await this.sendOrEdit(this.buffer);
+            await this.sendOrEdit(makeHtmlSafe(this.buffer), true);
         }
     }
     async finalize() {
@@ -283,8 +258,8 @@ export class StreamAccumulator {
         }
         if (this.buffer) {
             // Final edit with complete text including thinking blockquote and usage footer
-            const fullText = this.buildFullText(true);
-            await this.sendOrEdit(fullText);
+            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
@@ -294,6 +269,12 @@ export class StreamAccumulator {
             await this.sendOrEdit(`<blockquote expandable>💭 Thinking\n${escapeHtml(thinkingPreview)}</blockquote>`, true);
         }
     }
+    clearEditTimer() {
+        if (this.editTimer) {
+            clearTimeout(this.editTimer);
+            this.editTimer = null;
+        }
+    }
     /** Soft reset: clear buffer/state but keep tgMessageId so next turn edits the same message */
     softReset() {
         this.buffer = '';
@@ -305,10 +286,7 @@ export class StreamAccumulator {
         this.toolIndicators = [];
         this.finished = false;
         this.turnUsage = null;
-        if (this.editTimer) {
-            clearTimeout(this.editTimer);
-            this.editTimer = null;
-        }
+        this.clearEditTimer(); // Ensure cleanup
     }
     /** Full reset: also clears tgMessageId (next send creates a new message) */
     reset() {
@@ -356,25 +334,145 @@ export function formatUsageFooter(usage) {
     return `<i>${parts.join(' · ')}</i>`;
 }
 // ── Sub-agent detection patterns ──
-const SUB_AGENT_TOOL_PATTERNS = [/agent/i, /dispatch/i, /^task$/i];
+const CC_SUB_AGENT_TOOLS = new Set([
+    'Task', // Primary CC spawning tool
+    'dispatch_agent', // Legacy/alternative tool
+    'create_agent', // Test compatibility
+    'AgentRunner' // Test compatibility
+]);
 export function isSubAgentTool(toolName) {
-    return SUB_AGENT_TOOL_PATTERNS.some(p => p.test(toolName));
+    return CC_SUB_AGENT_TOOLS.has(toolName);
+}
+/** Extract a human-readable summary from partial/complete JSON tool input.
+ *  Looks for prompt, task, command, description fields — returns the first found, truncated.
+ */
+export function extractSubAgentSummary(jsonInput, maxLen = 150) {
+    try {
+        const parsed = JSON.parse(jsonInput);
+        const value = parsed.prompt || parsed.task || parsed.command || parsed.description || parsed.message || '';
+        if (typeof value === 'string' && value.length > 0) {
+            return value.length > maxLen ? value.slice(0, maxLen) + '…' : value;
+        }
+    }
+    catch {
+        // Partial JSON — try regex extraction for common patterns
+        for (const key of ['prompt', 'task', 'command', 'description', 'message']) {
+            const re = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)`, 'i');
+            const m = jsonInput.match(re);
+            if (m?.[1]) {
+                const val = m[1].replace(/\\n/g, ' ').replace(/\\"/g, '"');
+                return val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
+            }
+        }
+    }
+    return '';
+}
+/**
+ * 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.
+ */
+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) {
+            const val = parsed[key];
+            if (typeof val === 'string' && val.trim()) {
+                return val.trim().slice(0, 80);
+            }
+        }
+        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;
+        }
+        return '';
+    }
+    catch {
+        // JSON incomplete during streaming — extract first complete field value
+        return extractFieldFromPartialJson(jsonInput, labelFields) ?? '';
+    }
+}
+/** Extract the first complete string value for any of the given keys from partial JSON. */
+function extractFieldFromPartialJson(input, keys) {
+    for (const key of keys) {
+        const idx = input.indexOf(`"${key}"`);
+        if (idx === -1)
+            continue;
+        const afterKey = input.slice(idx + key.length + 2);
+        const colonIdx = afterKey.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const afterColon = afterKey.slice(colonIdx + 1).trimStart();
+        if (!afterColon.startsWith('"'))
+            continue;
+        // Walk the string handling escapes
+        let i = 1, value = '';
+        while (i < afterColon.length) {
+            if (afterColon[i] === '\\' && i + 1 < afterColon.length) {
+                value += afterColon[i + 1] === 'n' ? ' ' : afterColon[i + 1];
+                i += 2;
+            }
+            else if (afterColon[i] === '"') {
+                if (value.trim())
+                    return value.trim().slice(0, 80);
+                break;
+            }
+            else {
+                value += afterColon[i];
+                i++;
+            }
+        }
+    }
+    return null;
 }
 export class SubAgentTracker {
     chatId;
     sender;
-    getMainMessageId;
     agents = new Map(); // toolUseId → info
     blockToAgent = new Map(); // blockIndex → toolUseId
     sendQueue = Promise.resolve();
+    teamName = null;
+    mailboxPath = null;
+    mailboxWatching = false;
+    lastMailboxCount = 0;
+    onAllReported = null;
+    hasPendingFollowUp = false;
     constructor(options) {
         this.chatId = options.chatId;
         this.sender = options.sender;
-        this.getMainMessageId = options.getMainMessageId;
     }
     get activeAgents() {
         return [...this.agents.values()];
     }
+    /** Returns true if any sub-agents were tracked in this turn (including completed ones) */
+    get hadSubAgents() {
+        return this.agents.size > 0;
+    }
+    /** Returns true if any sub-agents are in dispatched state (spawned but no result yet) */
+    get hasDispatchedAgents() {
+        return [...this.agents.values()].some(a => a.status === 'dispatched');
+    }
+    /** Mark all dispatched agents as completed — used when CC reports results
+     *  in its main text response rather than via tool_result events.
+     */
+    markDispatchedAsReportedInMain() {
+        for (const [, info] of this.agents) {
+            if (info.status !== 'dispatched' || !info.tgMessageId)
+                continue;
+            info.status = 'completed';
+            const label = info.label || info.toolName;
+            const text = `✅ ${escapeHtml(label)} — see main message`;
+            this.sendQueue = this.sendQueue.then(async () => {
+                try {
+                    await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
+                }
+                catch { /* ignore */ }
+            });
+        }
+    }
     async handleEvent(event) {
         switch (event.type) {
             case 'content_block_start':
@@ -390,11 +488,80 @@ export class SubAgentTracker {
             case 'content_block_stop':
                 await this.onBlockStop(event);
                 break;
-            case 'message_start':
-                // New turn — reset tracker
-                this.reset();
-                break;
+            // NOTE: message_start reset is handled by the bridge (not here)
+            // so it can check hadSubAgents before clearing state
+        }
+    }
+    /** Handle a tool_result event — marks the sub-agent as completed with collapsible result */
+    /** Set agent metadata from structured tool_use_result */
+    setAgentMetadata(toolUseId, meta) {
+        const info = this.agents.get(toolUseId);
+        if (!info)
+            return;
+        if (meta.agentName)
+            info.agentName = meta.agentName;
+    }
+    /** Mark an agent as completed externally (e.g. from bridge follow-up) */
+    markCompleted(toolUseId, _reason) {
+        const info = this.agents.get(toolUseId);
+        if (!info || info.status === 'completed')
+            return;
+        info.status = 'completed';
+        // Check if all agents are done
+        const allDone = ![...this.agents.values()].some(a => a.status === 'dispatched');
+        if (allDone && this.onAllReported) {
+            this.onAllReported();
+            this.stopMailboxWatch();
+        }
+    }
+    async handleToolResult(toolUseId, result) {
+        const info = this.agents.get(toolUseId);
+        if (!info || !info.tgMessageId)
+            return;
+        // Detect background agent spawn confirmations — keep as dispatched, don't mark completed
+        // Spawn confirmations contain "agent_id:" and "Spawned" patterns
+        const isSpawnConfirmation = /agent_id:\s*\S+@\S+/.test(result) || /[Ss]pawned\s+successfully/i.test(result);
+        if (isSpawnConfirmation) {
+            // Extract agent name from spawn confirmation for mailbox matching
+            const nameMatch = result.match(/name:\s*(\S+)/);
+            if (nameMatch && !info.agentName)
+                info.agentName = nameMatch[1];
+            const agentIdMatch = result.match(/agent_id:\s*(\S+)@/);
+            if (agentIdMatch && !info.agentName)
+                info.agentName = agentIdMatch[1];
+            // Mark as dispatched — this enables mailbox watching and prevents idle timeout
+            info.status = 'dispatched';
+            info.dispatchedAt = Date.now();
+            const label = info.label || info.toolName;
+            const text = `🤖 ${escapeHtml(label)} — Spawned, waiting for results…`;
+            this.sendQueue = this.sendQueue.then(async () => {
+                try {
+                    await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
+                }
+                catch { /* ignore */ }
+            });
+            await this.sendQueue;
+            return;
         }
+        // Skip if already completed (e.g. via mailbox)
+        if (info.status === 'completed')
+            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>`;
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
+            }
+            catch {
+                // Ignore edit failures
+            }
+        });
+        await this.sendQueue;
     }
     async onBlockStart(event) {
         if (event.content_block.type !== 'tool_use')
@@ -408,24 +575,24 @@ export class SubAgentTracker {
             blockIndex: event.index,
             tgMessageId: null,
             status: 'running',
+            label: '',
+            agentName: '',
             inputPreview: '',
+            dispatchedAt: null,
         };
         this.agents.set(block.id, info);
         this.blockToAgent.set(event.index, block.id);
-        // Send reply message
-        const mainMsgId = this.getMainMessageId();
-        if (mainMsgId) {
-            this.sendQueue = this.sendQueue.then(async () => {
-                try {
-                    const msgId = await this.sender.replyToMessage(this.chatId, `🔄 Sub-agent spawned: <code>${escapeHtml(block.name)}</code>`, mainMsgId, 'HTML');
-                    info.tgMessageId = msgId;
-                }
-                catch (err) {
-                    // Silently ignore — main stream continues regardless
-                }
-            });
-            await this.sendQueue;
-        }
+        // Send standalone message (no reply_to — cleaner in private chat)
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                const msgId = await this.sender.sendMessage(this.chatId, '🤖 Starting sub-agent…', 'HTML');
+                info.tgMessageId = msgId;
+            }
+            catch (err) {
+                // Silently ignore — main stream continues regardless
+            }
+        });
+        await this.sendQueue;
     }
     async onInputDelta(event) {
         const toolUseId = this.blockToAgent.get(event.index);
@@ -435,21 +602,39 @@ export class SubAgentTracker {
         if (!info || !info.tgMessageId)
             return;
         info.inputPreview += event.delta.partial_json;
-        // Throttle: only update when we have a reasonable chunk (every 200 chars)
-        if (info.inputPreview.length % 200 > 50)
-            return;
-        const preview = info.inputPreview.length > 300
-            ? info.inputPreview.slice(0, 300) + '…'
-            : info.inputPreview;
-        this.sendQueue = this.sendQueue.then(async () => {
+        // Extract agent name from input JSON (used for mailbox matching)
+        if (!info.agentName) {
             try {
-                await this.sender.editMessage(this.chatId, info.tgMessageId, `🔄 Sub-agent: <code>${escapeHtml(info.toolName)}</code>\n\n<pre>${escapeHtml(preview)}</pre>`, 'HTML');
+                const parsed = JSON.parse(info.inputPreview);
+                if (typeof parsed.name === 'string' && parsed.name.trim()) {
+                    info.agentName = parsed.name.trim();
+                }
             }
             catch {
-                // Ignore edit failures (rate limits, not modified, etc.)
+                // Partial JSON — try extracting name field
+                const nameMatch = info.inputPreview.match(/"name"\s*:\s*"([^"]+)"/);
+                if (nameMatch)
+                    info.agentName = nameMatch[1];
             }
-        });
-        await this.sendQueue;
+        }
+        // Try to extract an agent label
+        if (!info.label) {
+            const label = extractAgentLabel(info.inputPreview);
+            if (label) {
+                info.label = label;
+                // Once we have a label, update the message to show it
+                const displayLabel = info.label;
+                this.sendQueue = this.sendQueue.then(async () => {
+                    try {
+                        await this.sender.editMessage(this.chatId, info.tgMessageId, `🤖 ${escapeHtml(displayLabel)} — Working…`, 'HTML');
+                    }
+                    catch {
+                        // Ignore edit failures
+                    }
+                });
+                await this.sendQueue;
+            }
+        }
     }
     async onBlockStop(event) {
         const toolUseId = this.blockToAgent.get(event.index);
@@ -458,25 +643,17 @@ export class SubAgentTracker {
         const info = this.agents.get(toolUseId);
         if (!info || !info.tgMessageId)
             return;
-        info.status = 'completed';
-        // Extract a summary from the input preview (first ~100 chars)
-        let summary = '';
-        try {
-            const parsed = JSON.parse(info.inputPreview);
-            // Common patterns: { prompt: "..." }, { task: "..." }, { command: "..." }
-            summary = parsed.prompt || parsed.task || parsed.command || parsed.description || '';
-            if (typeof summary === 'string' && summary.length > 100) {
-                summary = summary.slice(0, 100) + '…';
-            }
-        }
-        catch {
-            summary = info.inputPreview.slice(0, 100);
-            if (info.inputPreview.length > 100)
-                summary += '…';
+        // 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;
         }
-        const text = summary
-            ? `✅ Sub-agent completed: <code>${escapeHtml(info.toolName)}</code>\n<i>${escapeHtml(summary)}</i>`
-            : `✅ Sub-agent completed: <code>${escapeHtml(info.toolName)}</code>`;
+        const displayLabel = info.label || info.toolName;
+        const text = `🤖 ${escapeHtml(displayLabel)} — Working…`;
         this.sendQueue = this.sendQueue.then(async () => {
             try {
                 await this.sender.editMessage(this.chatId, info.tgMessageId, text, 'HTML');
@@ -486,11 +663,137 @@ export class SubAgentTracker {
             }
         });
         await this.sendQueue;
+        // Start elapsed timer — update every 15s to show progress
+    }
+    /** Start a periodic timer that edits the message with elapsed time */
+    /** Set callback invoked when ALL dispatched sub-agents have mailbox results. */
+    setOnAllReported(cb) {
+        this.onAllReported = cb;
+    }
+    /** Set the CC team name (extracted from spawn confirmation tool_result). */
+    setTeamName(name) {
+        this.teamName = name;
+        this.mailboxPath = join(homedir(), '.claude', 'teams', name, 'inboxes', 'team-lead.json');
+    }
+    get currentTeamName() { return this.teamName; }
+    get isMailboxWatching() { return this.mailboxWatching; }
+    /** Start watching the mailbox file for sub-agent results. */
+    startMailboxWatch() {
+        if (this.mailboxWatching) {
+            return;
+        }
+        if (!this.mailboxPath) {
+            return;
+        }
+        this.mailboxWatching = true;
+        // Ensure directory exists so watchFile doesn't error
+        const dir = dirname(this.mailboxPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Start from 0 — process all messages including pre-existing ones
+        // Background agents may finish before the watcher starts
+        this.lastMailboxCount = 0;
+        // Process immediately in case messages arrived before watching
+        this.processMailbox();
+        watchFile(this.mailboxPath, { interval: 2000 }, () => {
+            this.processMailbox();
+        });
+    }
+    /** Stop watching the mailbox file. */
+    stopMailboxWatch() {
+        if (!this.mailboxWatching || !this.mailboxPath)
+            return;
+        try {
+            unwatchFile(this.mailboxPath);
+        }
+        catch { /* ignore */ }
+        this.mailboxWatching = false;
+    }
+    /** Read and parse the mailbox file. Returns [] on any error. */
+    readMailboxMessages() {
+        if (!this.mailboxPath || !existsSync(this.mailboxPath))
+            return [];
+        try {
+            const raw = readFileSync(this.mailboxPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Process new mailbox messages and update sub-agent TG messages. */
+    processMailbox() {
+        const messages = this.readMailboxMessages();
+        if (messages.length <= this.lastMailboxCount)
+            return;
+        const newMessages = messages.slice(this.lastMailboxCount);
+        this.lastMailboxCount = messages.length;
+        for (const msg of newMessages) {
+            // Don't filter by msg.read — CC may read its mailbox before our 2s poll fires
+            // We track by message count (lastMailboxCount) to avoid duplicates
+            // Skip idle notifications (JSON objects, not real results)
+            if (msg.text.startsWith('{'))
+                continue;
+            // Match msg.from to a tracked sub-agent
+            const matched = this.findAgentByFrom(msg.from);
+            if (!matched) {
+                console.error(`[MAILBOX] No match for from="${msg.from}". Agents: ${[...this.agents.values()].map(a => `${a.agentName}/${a.label}/${a.status}`).join(', ')}`);
+                continue;
+            }
+            matched.status = 'completed';
+            if (!matched.tgMessageId)
+                continue;
+            // React with ✅ instead of editing — avoids race conditions
+            const msgId = matched.tgMessageId;
+            const emoji = msg.color === 'red' ? '👎' : '👍';
+            this.sendQueue = this.sendQueue.then(async () => {
+                try {
+                    await this.sender.setReaction?.(this.chatId, msgId, emoji);
+                }
+                catch { /* ignore — reaction might not be supported */ }
+            });
+        }
+        // Check if ALL dispatched agents are now completed
+        if (this.onAllReported && !this.hasDispatchedAgents && this.agents.size > 0) {
+            // All done — invoke callback
+            const cb = this.onAllReported;
+            // Defer slightly to let edits flush
+            setTimeout(() => cb(), 500);
+        }
+    }
+    /** Find a tracked sub-agent whose label matches the mailbox message's `from` field. */
+    findAgentByFrom(from) {
+        const fromLower = from.toLowerCase();
+        for (const info of this.agents.values()) {
+            if (info.status !== 'dispatched')
+                continue;
+            // Primary match: agentName (CC's internal agent name, used as mailbox 'from')
+            if (info.agentName && info.agentName.toLowerCase() === fromLower) {
+                return info;
+            }
+            // Fallback: fuzzy label match
+            const label = (info.label || info.toolName).toLowerCase();
+            if (label === fromLower || label.includes(fromLower) || fromLower.includes(label)) {
+                return info;
+            }
+        }
+        return null;
     }
     reset() {
+        // Stop mailbox watching
+        this.stopMailboxWatch();
+        // Clear all elapsed timers before resetting
+        for (const info of this.agents.values()) {
+        }
         this.agents.clear();
         this.blockToAgent.clear();
         this.sendQueue = Promise.resolve();
+        this.teamName = null;
+        this.mailboxPath = null;
+        this.lastMailboxCount = 0;
+        this.onAllReported = null;
     }
 }
 // ── Utility: split a completed text into TG-sized chunks ──