@fonz/tgcc 0.6.17 → 0.6.19

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.
@@ -28,7 +34,63 @@ export function makeHtmlSafe(text) {
 export function makeMarkdownSafe(text) {
     return makeHtmlSafe(text);
 }
-// ── Stream Accumulator ──
+function toolEmoji(toolName) {
+    switch (toolName) {
+        case 'Read': return '👓';
+        case 'Write': return '✏️';
+        case 'Edit':
+        case 'MultiEdit': return '✏️';
+        case 'Grep':
+        case 'Search':
+        case 'Glob': return '🔍';
+        case 'WebFetch':
+        case 'WebSearch': return '🌐';
+        default: return '⚡';
+    }
+}
+/** Render a single segment to its HTML string. */
+function renderSegment(seg) {
+    switch (seg.type) {
+        case 'thinking':
+            return `<blockquote expandable>💭 ${seg.rawText ? markdownToTelegramHtml(seg.rawText.length > 1024 ? seg.rawText.slice(0, 1024) + '…' : seg.rawText) : 'Processing…'}</blockquote>`;
+        case 'text':
+            return seg.rawText ? makeHtmlSafe(seg.rawText) : '';
+        case 'tool': {
+            const emoji = toolEmoji(seg.toolName);
+            const inputPart = seg.inputPreview ? ` <code>${escapeHtml(seg.inputPreview)}</code>` : '';
+            if (seg.status === 'resolved') {
+                const resultLine = seg.resultStat ? `\n<code>${escapeHtml(seg.resultStat)}</code>` : '';
+                return `<blockquote>${emoji} ${seg.elapsed ?? '?'} · ✔${inputPart}${resultLine}</blockquote>`;
+            }
+            else if (seg.status === 'error') {
+                return `<blockquote>${emoji} ${seg.elapsed ?? '?'} · ✘${inputPart}</blockquote>`;
+            }
+            else {
+                return `<blockquote>${emoji}${inputPart || ' …'}</blockquote>`;
+            }
+        }
+        case 'subagent': {
+            const label = seg.label || seg.toolName;
+            const elapsed = formatElapsed(Date.now() - seg.startTime);
+            const progressBlock = seg.progressLines.length > 0
+                ? '\n' + seg.progressLines.join('\n')
+                : '';
+            if (seg.status === 'completed') {
+                return `<blockquote>🤖 ${escapeHtml(label)} — ✅ Done (${elapsed})${progressBlock}</blockquote>`;
+            }
+            else {
+                return `<blockquote>🤖 ${escapeHtml(label)} — Working (${elapsed})…${progressBlock}</blockquote>`;
+            }
+        }
+        case 'supervisor':
+        case 'usage':
+        case 'image':
+            return seg.content;
+        default:
+            return '';
+    }
+}
+// ── Stream Accumulator (single-bubble FIFO) ──
 export class StreamAccumulator {
     chatId;
     sender;
@@ -36,38 +98,44 @@ export class StreamAccumulator {
     splitThreshold;
     logger;
     onError;
+    // Segment FIFO
+    segments = [];
     // State
     tgMessageId = null;
-    buffer = '';
-    thinkingBuffer = '';
-    imageBase64Buffer = '';
-    currentBlockType = null;
-    lastEditTime = 0;
-    editTimer = null;
-    thinkingIndicatorShown = false;
-    messageIds = []; // all message IDs sent during this turn
-    finished = false;
+    messageIds = [];
+    sealed = false;
     sendQueue = Promise.resolve();
     turnUsage = null;
-    /** Usage from the most recent message_start event — represents a single API call's context (not cumulative). */
     _lastMsgStartCtx = null;
-    // Per-tool-use independent indicator messages (persists across resets)
-    toolMessages = new Map();
-    toolInputBuffers = new Map(); // tool block ID → accumulated input JSON
-    currentToolBlockId = null;
+    // Per-block streaming state
+    currentBlockType = null;
+    currentBlockId = null;
+    currentSegmentIdx = -1; // index into segments[] for currently-building block
+    // Tool streaming state
+    toolInputBuffers = new Map(); // blockId → accumulated JSON input
+    // Image streaming state
+    imageBase64Buffer = '';
+    // Rate limiting / render scheduling
+    lastEditTime = 0;
+    flushTimer = null;
+    dirty = false;
+    // Delayed first send (fix: don't create TG message until real content arrives)
+    turnStartTime = 0;
+    firstSendReady = true; // true until first reset() — pre-turn sends are unrestricted
+    firstSendTimer = null;
+    // Tool hide timers (fix: don't flash ⚡ for fast tools that resolve <500ms)
+    toolHideTimers = new Map();
     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) {
-        // 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,
@@ -80,12 +148,20 @@ export class StreamAccumulator {
             this.turnUsage = usage;
         }
     }
+    /** Append a supervisor message segment. Renders in stream order with everything else. */
+    addSupervisorMessage(text) {
+        const preview = text.length > 500 ? text.slice(0, 500) + '…' : text;
+        const seg = {
+            type: 'supervisor',
+            content: `<blockquote>🦞 ${escapeHtml(preview)}</blockquote>`,
+        };
+        this.segments.push(seg);
+        this.requestRender();
+    }
     // ── Process stream events ──
     async handleEvent(event) {
         switch (event.type) {
             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 = {
@@ -97,81 +173,129 @@ export class StreamAccumulator {
                 break;
             }
             case 'content_block_start':
-                await this.onContentBlockStart(event);
+                this.onContentBlockStart(event);
                 break;
             case 'content_block_delta':
                 await this.onContentBlockDelta(event);
                 break;
             case 'content_block_stop':
-                if (this.currentBlockType === 'thinking' && this.thinkingBuffer) {
-                    // Thinking block complete — store for later rendering with text
-                    // Will be prepended as expandable blockquote when text starts or on finalize
-                }
-                else if (this.currentBlockType === 'image' && this.imageBase64Buffer) {
-                    await this.sendImage();
-                }
-                this.currentBlockType = null;
+                await this.onContentBlockStop(event);
                 break;
             case 'message_stop':
-                await this.finalize();
+                // message_stop within a tool-use loop — finalize is called separately by bridge on `result`
                 break;
         }
     }
-    async onContentBlockStart(event) {
+    onContentBlockStart(event) {
         const blockType = event.content_block.type;
+        this.currentBlockType = blockType;
         if (blockType === 'thinking') {
-            this.currentBlockType = 'thinking';
-            if (!this.thinkingIndicatorShown && !this.buffer) {
-                await this.sendOrEdit('<blockquote>💭 Thinking...</blockquote>', true);
-                this.thinkingIndicatorShown = true;
-            }
+            const seg = { type: 'thinking', rawText: '', content: '' };
+            seg.content = renderSegment(seg);
+            this.segments.push(seg);
+            this.currentSegmentIdx = this.segments.length - 1;
+            this.requestRender();
         }
         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
-            }
+            const seg = { type: 'text', rawText: '', content: '' };
+            this.segments.push(seg);
+            this.currentSegmentIdx = this.segments.length - 1;
         }
         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);
+            this.currentBlockId = block.id;
+            this.toolInputBuffers.set(block.id, '');
+            if (isSubAgentTool(block.name)) {
+                const seg = {
+                    type: 'subagent',
+                    id: block.id,
+                    toolName: block.name,
+                    label: '',
+                    status: 'running',
+                    startTime: Date.now(),
+                    progressLines: [],
+                    content: '',
+                };
+                seg.content = renderSegment(seg);
+                this.segments.push(seg);
+                this.currentSegmentIdx = this.segments.length - 1;
+            }
+            else {
+                const seg = {
+                    type: 'tool',
+                    id: block.id,
+                    toolName: block.name,
+                    status: 'pending',
+                    startTime: Date.now(),
+                    content: '',
+                };
+                seg.content = renderSegment(seg);
+                this.segments.push(seg);
+                this.currentSegmentIdx = this.segments.length - 1;
+                // Suppress the ⚡ pending indicator for 500ms. If the tool resolves within that window
+                // the hide timer is cancelled in resolveToolMessage and we render directly as ✅.
+                const toolBlockId = block.id;
+                this.toolHideTimers.set(toolBlockId, setTimeout(() => {
+                    this.toolHideTimers.delete(toolBlockId);
+                    this.requestRender();
+                }, 500));
+            }
+            this.requestRender();
         }
         else if (blockType === 'image') {
-            this.currentBlockType = 'image';
             this.imageBase64Buffer = '';
         }
     }
     async onContentBlockDelta(event) {
         if (this.currentBlockType === 'text' && 'delta' in event) {
             const delta = event.delta;
-            if (delta?.type === 'text_delta') {
-                this.buffer += delta.text;
-                // Force split/truncation if buffer exceeds 50KB
-                if (this.buffer.length > 50_000) {
-                    await this.forceSplitOrTruncate();
-                    return; // Skip throttledEdit - already handled in forceSplitOrTruncate
+            if (delta?.type === 'text_delta' && this.currentSegmentIdx >= 0) {
+                const seg = this.segments[this.currentSegmentIdx];
+                seg.rawText += delta.text;
+                seg.content = renderSegment(seg);
+                if (seg.rawText.length > 50_000) {
+                    await this.forceSplitText(seg);
+                    return;
                 }
-                await this.throttledEdit();
+                this.requestRender();
             }
         }
         else if (this.currentBlockType === 'thinking' && 'delta' in event) {
             const delta = event.delta;
-            if (delta?.type === 'thinking_delta' && delta.thinking) {
-                this.thinkingBuffer += delta.thinking;
+            if (delta?.type === 'thinking_delta' && delta.thinking && this.currentSegmentIdx >= 0) {
+                const seg = this.segments[this.currentSegmentIdx];
+                seg.rawText += delta.thinking;
+                seg.content = renderSegment(seg);
+                this.requestRender();
             }
         }
         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;
+            if (delta?.type === 'input_json_delta' && delta.partial_json && this.currentBlockId) {
+                const blockId = this.currentBlockId;
                 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);
+                const next = prev + delta.partial_json;
+                this.toolInputBuffers.set(blockId, next);
+                // Update segment preview if we have enough input
+                if (this.currentSegmentIdx >= 0) {
+                    const seg = this.segments[this.currentSegmentIdx];
+                    if (seg.type === 'tool' || seg.type === 'subagent') {
+                        const toolName = seg.type === 'tool' ? seg.toolName : seg.toolName;
+                        const summary = extractToolInputSummary(toolName, next, 80, true);
+                        if (summary) {
+                            seg.inputPreview = summary;
+                        }
+                        if (seg.type === 'subagent') {
+                            const extracted = extractAgentLabel(next);
+                            if (extracted.label && labelFieldPriority(extracted.field) < labelFieldPriority(seg.labelField ?? null)) {
+                                seg.label = extracted.label;
+                                seg.labelField = extracted.field;
+                            }
+                        }
+                        seg.content = renderSegment(seg);
+                        this.requestRender();
+                    }
+                }
             }
         }
         else if (this.currentBlockType === 'image' && 'delta' in event) {
@@ -181,45 +305,336 @@ export class StreamAccumulator {
             }
         }
     }
+    async onContentBlockStop(_event) {
+        if (this.currentBlockType === 'tool_use' && this.currentBlockId && this.currentSegmentIdx >= 0) {
+            const blockId = this.currentBlockId;
+            const seg = this.segments[this.currentSegmentIdx];
+            const inputJson = this.toolInputBuffers.get(blockId) ?? '';
+            if (seg.type === 'subagent') {
+                // Finalize label from complete input
+                const extracted = extractAgentLabel(inputJson);
+                if (extracted.label) {
+                    seg.label = extracted.label;
+                    seg.labelField = extracted.field;
+                }
+                // Mark as dispatched (input complete, waiting for tool_result)
+                seg.status = 'dispatched';
+                seg.content = renderSegment(seg);
+                this.requestRender();
+            }
+            else if (seg.type === 'tool') {
+                // Finalize preview from complete input
+                const summary = extractToolInputSummary(seg.toolName, inputJson, 80);
+                if (summary)
+                    seg.inputPreview = summary;
+                seg.content = renderSegment(seg);
+                this.requestRender();
+            }
+        }
+        else if (this.currentBlockType === 'image' && this.imageBase64Buffer) {
+            await this.sendImage();
+        }
+        this.currentBlockType = null;
+        this.currentBlockId = null;
+        this.currentSegmentIdx = -1;
+    }
+    // ── Public tool resolution API ──
+    /** Resolve a tool indicator with success/failure status. Called by bridge on tool_result. */
+    resolveToolMessage(blockId, isError, errorMessage, resultContent, toolUseResult) {
+        const segIdx = this.segments.findIndex(s => (s.type === 'tool' || s.type === 'subagent') && s.id === blockId);
+        if (segIdx < 0)
+            return;
+        const seg = this.segments[segIdx];
+        if (seg.type === 'subagent') {
+            // Sub-agent spawn confirmation → mark as dispatched/waiting
+            const isSpawnConfirmation = toolUseResult?.status === 'teammate_spawned' ||
+                (typeof resultContent === 'string' && (/agent_id:\s*\S+@\S+/.test(resultContent) || /[Ss]pawned\s+successfully/i.test(resultContent)));
+            if (isSpawnConfirmation) {
+                seg.status = 'dispatched';
+                seg.content = renderSegment(seg);
+                this.requestRender();
+                return;
+            }
+            // Tool result (synchronous completion) → mark completed
+            seg.status = 'completed';
+            seg.content = renderSegment(seg);
+            this.requestRender();
+            return;
+        }
+        if (seg.type === 'tool') {
+            // Cancel the hide timer — tool is now visible in its final state.
+            // If it resolved within 500ms the timer was still running; cancelling it means
+            // the ⚡ pending indicator was never shown and we render directly as ✅.
+            const hideTimer = this.toolHideTimers.get(blockId);
+            if (hideTimer !== undefined) {
+                clearTimeout(hideTimer);
+                this.toolHideTimers.delete(blockId);
+            }
+            // MCP media tools: remove segment on success (media itself is the result)
+            if (StreamAccumulator.MCP_MEDIA_TOOLS.has(seg.toolName) && !isError) {
+                this.segments.splice(segIdx, 1);
+                this.requestRender();
+                return;
+            }
+            const elapsed = ((Date.now() - seg.startTime) / 1000).toFixed(1) + 's';
+            seg.elapsed = elapsed;
+            if (isError) {
+                seg.status = 'error';
+            }
+            else {
+                seg.status = 'resolved';
+                // Finalize input preview from buffer if not set
+                const inputJson = this.toolInputBuffers.get(blockId) ?? '';
+                if (!seg.inputPreview) {
+                    const summary = extractToolInputSummary(seg.toolName, inputJson);
+                    if (summary)
+                        seg.inputPreview = summary;
+                }
+                // Compute result stat
+                const resultStat = extractToolResultStat(seg.toolName, resultContent, toolUseResult);
+                if (resultStat)
+                    seg.resultStat = resultStat;
+            }
+            this.toolInputBuffers.delete(blockId);
+            seg.content = renderSegment(seg);
+            this.requestRender();
+        }
+    }
+    /** Update a sub-agent segment status (called by bridge on task_started/progress/completed). */
+    updateSubAgentSegment(blockId, status, label) {
+        const seg = this.segments.find(s => s.type === 'subagent' && s.id === blockId);
+        if (!seg)
+            return;
+        if (seg.status === 'completed')
+            return; // don't downgrade
+        seg.status = status;
+        if (label && label.length > seg.label.length)
+            seg.label = label;
+        seg.content = renderSegment(seg);
+        this.requestRender();
+    }
+    /** Append a high-signal progress line to a sub-agent segment (called by bridge on task_progress). */
+    appendSubAgentProgress(blockId, description, lastToolName) {
+        const seg = this.segments.find(s => s.type === 'subagent' && s.id === blockId);
+        if (!seg || seg.status === 'completed')
+            return;
+        const line = formatProgressLine(description, lastToolName);
+        if (!line)
+            return;
+        seg.progressLines.push(line);
+        if (seg.progressLines.length > MAX_PROGRESS_LINES)
+            seg.progressLines.shift();
+        seg.content = renderSegment(seg);
+        this.requestRender();
+    }
+    static MCP_MEDIA_TOOLS = new Set(['mcp__tgcc__send_image', 'mcp__tgcc__send_file', 'mcp__tgcc__send_voice']);
+    // ── Rendering ──
+    /** Render all segments to one HTML string. */
+    renderHtml() {
+        const parts = this.segments
+            .map(s => {
+            // Hide pending tool segments until 500ms has elapsed — fast tools go directly to resolved state
+            if (s.type === 'tool' && s.status === 'pending' && this.toolHideTimers.has(s.id))
+                return '';
+            return s.content;
+        })
+            .filter(c => c.length > 0);
+        return parts.join('\n') || '…';
+    }
+    /** Force any pending timer to fire immediately and await the send queue.
+     *  Bypasses the first-send gate (like finalize). Useful in tests. */
+    async flush() {
+        this.firstSendReady = true;
+        this.clearFirstSendTimer();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+            this.flushRender();
+        }
+        else if (this.dirty && !this.flushInFlight && !this.sealed) {
+            this.flushRender();
+        }
+        await this.sendQueue;
+    }
+    /** Mark dirty and schedule a throttled flush. The single entry point for all renders.
+     *  Data in → dirty flag → throttled flush → TG edit. One path, no re-entrant loops. */
+    flushInFlight = false;
+    requestRender() {
+        this.dirty = true;
+        // Don't schedule a new flush while one is in-flight (waiting on sendQueue).
+        // The in-flight flush will reschedule after the edit completes.
+        if (!this.flushTimer && !this.flushInFlight) {
+            const elapsed = Date.now() - this.lastEditTime;
+            const delay = Math.max(0, this.editIntervalMs - elapsed);
+            this.flushTimer = setTimeout(() => this.flushRender(), delay);
+        }
+    }
+    /** Timer callback: consumes dirty flag and chains one _doSendOrEdit onto sendQueue. */
+    flushRender() {
+        this.flushTimer = null;
+        if (!this.dirty || this.sealed)
+            return;
+        // Gate: delay first TG message until real text content arrives or 2s have passed.
+        if (!this.tgMessageId && !this.checkFirstSendReady()) {
+            if (!this.firstSendTimer) {
+                const remaining = Math.max(0, 2000 - (Date.now() - this.turnStartTime));
+                this.firstSendTimer = setTimeout(() => {
+                    this.firstSendTimer = null;
+                    this.firstSendReady = true;
+                    this.requestRender();
+                }, remaining);
+            }
+            // dirty stays true; requestRender() will re-schedule when timer fires
+            return;
+        }
+        this.dirty = false;
+        this.flushInFlight = true;
+        const html = this.renderHtml();
+        const afterFlush = () => {
+            this.flushInFlight = false;
+            // If new data arrived while we were in-flight, schedule another flush
+            if (this.dirty && !this.sealed) {
+                this.requestRender();
+            }
+        };
+        if (html.length > this.splitThreshold) {
+            this.sendQueue = this.sendQueue
+                .then(() => this.splitMessage())
+                .then(afterFlush, (err) => { afterFlush(); this.logger?.error?.({ err }, 'flushRender splitMessage failed'); });
+        }
+        else {
+            this.sendQueue = this.sendQueue
+                .then(() => this._doSendOrEdit(html || '…'))
+                .then(afterFlush, (err) => { afterFlush(); this.logger?.error?.({ err }, 'flushRender failed'); });
+        }
+    }
+    /** Split oversized message — called from within the sendQueue chain, uses _doSendOrEdit directly. */
+    async splitMessage() {
+        // Find text segments to split on
+        let totalLen = 0;
+        let splitSegIdx = -1;
+        for (let i = 0; i < this.segments.length; i++) {
+            const seg = this.segments[i];
+            totalLen += seg.content.length + 1;
+            if (totalLen > this.splitThreshold && splitSegIdx < 0) {
+                splitSegIdx = i;
+            }
+        }
+        if (splitSegIdx <= 0) {
+            // Can't split cleanly — truncate the HTML
+            const html = this.renderHtml().slice(0, this.splitThreshold);
+            await this._doSendOrEdit(html);
+            return;
+        }
+        // Render first part, start new message with remainder
+        const firstSegs = this.segments.slice(0, splitSegIdx);
+        const restSegs = this.segments.slice(splitSegIdx);
+        const firstHtml = firstSegs.map(s => s.content).filter(Boolean).join('\n');
+        await this._doSendOrEdit(firstHtml);
+        // Start a new message for remainder
+        this.tgMessageId = null;
+        this.segments = restSegs;
+        const restHtml = this.renderHtml();
+        await this._doSendOrEdit(restHtml);
+    }
+    checkFirstSendReady() {
+        if (this.firstSendReady)
+            return true;
+        const textChars = this.segments
+            .filter((s) => s.type === 'text')
+            .reduce((sum, s) => sum + s.rawText.length, 0);
+        if (textChars >= 200 || Date.now() - this.turnStartTime >= 2000) {
+            this.firstSendReady = true;
+            this.clearFirstSendTimer();
+            return true;
+        }
+        return false;
+    }
+    clearFirstSendTimer() {
+        if (this.firstSendTimer) {
+            clearTimeout(this.firstSendTimer);
+            this.firstSendTimer = null;
+        }
+    }
+    /** Force-split when a text segment exceeds 50KB */
+    async forceSplitText(seg) {
+        const maxChars = 40_000;
+        const splitAt = findSplitPoint(seg.rawText, maxChars);
+        const firstPart = seg.rawText.slice(0, splitAt);
+        const remainder = seg.rawText.slice(splitAt);
+        // Replace the current text segment with truncated first part
+        seg.rawText = firstPart;
+        seg.content = renderSegment(seg);
+        await this.sendOrEdit(this.renderHtml());
+        // Start new message for remainder
+        this.tgMessageId = null;
+        const newSeg = { type: 'text', rawText: remainder, content: '' };
+        newSeg.content = renderSegment(newSeg);
+        this.segments = [newSeg];
+        this.currentSegmentIdx = 0;
+        await this.sendOrEdit(this.renderHtml());
+    }
+    async finalize() {
+        if (this.sealed)
+            return; // already finalized — guard against double-call (result + exit)
+        // Cancel any pending flush — we take over from here
+        this.clearFlushTimer();
+        // Ensure first send is unblocked — finalize is the last chance to send anything
+        this.firstSendReady = true;
+        this.clearFirstSendTimer();
+        // Append usage footer segment
+        if (this.turnUsage) {
+            const usageHtml = formatUsageFooter(this.turnUsage, this.turnUsage.model);
+            const seg = { type: 'usage', content: `<blockquote>📊 ${usageHtml}</blockquote>` };
+            this.segments.push(seg);
+        }
+        // Final render — chain directly onto sendQueue so it runs after any in-flight edits
+        const html = this.renderHtml();
+        if (html && html !== '…') {
+            this.sendQueue = this.sendQueue
+                .then(() => this._doSendOrEdit(html))
+                .catch(err => {
+                this.logger?.error?.({ err }, 'finalize failed');
+                this.onError?.(err, 'Failed to send/edit message');
+            });
+            await this.sendQueue;
+        }
+        this.sealed = true;
+    }
     // ── 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)).catch(err => {
+    async sendOrEdit(html) {
+        const safeHtml = html || '…';
+        this.sendQueue = this.sendQueue.then(() => this._doSendOrEdit(safeHtml)).catch(err => {
             this.logger?.error?.({ err }, 'sendOrEdit failed');
             this.onError?.(err, 'Failed to send/edit message');
         });
         return this.sendQueue;
     }
-    async _doSendOrEdit(text, rawHtml = false) {
-        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
+    async _doSendOrEdit(html) {
+        let text = html || '…';
+        if (!text.replace(/<[^>]*>/g, '').trim())
+            text = '…';
         this.lastEditTime = Date.now();
         try {
             if (!this.tgMessageId) {
-                this.tgMessageId = await this.sender.sendMessage(this.chatId, safeText, 'HTML');
+                this.tgMessageId = await this.sender.sendMessage(this.chatId, text, 'HTML');
                 this.messageIds.push(this.tgMessageId);
             }
             else {
-                await this.sender.editMessage(this.chatId, this.tgMessageId, safeText, 'HTML');
+                await this.sender.editMessage(this.chatId, this.tgMessageId, text, 'HTML');
             }
         }
         catch (err) {
             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 (harmless)
             if (err instanceof Error && err.message.includes('message is not modified'))
                 return;
-            // 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');
         }
     }
@@ -232,291 +647,54 @@ export class StreamAccumulator {
             this.messageIds.push(msgId);
         }
         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 = '';
     }
-    /** 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();
-        const elapsed = now - this.lastEditTime;
-        if (elapsed >= this.editIntervalMs) {
-            // Enough time passed — edit now
-            await this.doEdit();
-        }
-        else if (!this.editTimer) {
-            // Schedule an edit
-            const delay = this.editIntervalMs - elapsed;
-            this.editTimer = setTimeout(async () => {
-                this.editTimer = null;
-                if (!this.finished) {
-                    await this.doEdit();
-                }
-            }, delay);
-        }
-    }
-    /** 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) {
-            const thinkingPreview = this.thinkingBuffer.length > 1024
-                ? this.thinkingBuffer.slice(0, 1024) + '…'
-                : this.thinkingBuffer;
-            text += `<blockquote expandable>💭 Thinking\n${markdownToTelegramHtml(thinkingPreview)}</blockquote>\n`;
-        }
-        // Convert markdown buffer to HTML-safe text
-        text += makeHtmlSafe(this.buffer);
-        if (includeSuffix && this.turnUsage) {
-            text += '\n' + formatUsageFooter(this.turnUsage, this.turnUsage.model);
-        }
-        return { text, hasHtmlSuffix: includeSuffix && !!this.turnUsage };
-    }
-    async doEdit() {
-        if (!this.buffer)
-            return;
-        const { text, hasHtmlSuffix } = this.buildFullText();
-        // Check if we need to split
-        if (text.length > this.splitThreshold) {
-            await this.splitMessage();
-            return;
-        }
-        await this.sendOrEdit(text, true); // buildFullText already does makeHtmlSafe
-    }
-    async splitMessage() {
-        // Find a good split point near the threshold
-        const splitAt = findSplitPoint(this.buffer, this.splitThreshold);
-        const firstPart = this.buffer.slice(0, splitAt);
-        const remainder = this.buffer.slice(splitAt);
-        // Finalize current message with first part
-        await this.sendOrEdit(makeHtmlSafe(firstPart), true);
-        // Start a new message for remainder
-        this.tgMessageId = null;
-        this.buffer = remainder;
-        if (this.buffer) {
-            await this.sendOrEdit(makeHtmlSafe(this.buffer), true);
-        }
-    }
-    /** Emergency split/truncation when buffer exceeds 50KB absolute limit */
-    async forceSplitOrTruncate() {
-        const maxChars = 50_000;
-        if (this.buffer.length > maxChars) {
-            // Split at a reasonable point within the 50KB limit
-            const splitAt = findSplitPoint(this.buffer, maxChars - 200); // Leave some margin
-            const firstPart = this.buffer.slice(0, splitAt);
-            const remainder = this.buffer.slice(splitAt);
-            // Finalize current message with first part + truncation notice
-            const truncationNotice = '\n\n<i>[Output truncated - buffer limit exceeded]</i>';
-            await this.sendOrEdit(makeHtmlSafe(firstPart) + truncationNotice, true);
-            // Start a new message for remainder (up to another 50KB)
-            this.tgMessageId = null;
-            this.buffer = remainder.length > maxChars
-                ? remainder.slice(0, maxChars - 100) + '...'
-                : remainder;
-            if (this.buffer) {
-                await this.sendOrEdit(makeHtmlSafe(this.buffer), true);
-            }
-        }
-    }
-    async finalize() {
-        this.finished = true;
-        // Clear any pending edit timer
-        if (this.editTimer) {
-            clearTimeout(this.editTimer);
-            this.editTimer = null;
-        }
-        if (this.buffer) {
-            // Final edit with complete text including thinking blockquote and usage footer
-            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
-            const thinkingPreview = this.thinkingBuffer.length > 1024
-                ? this.thinkingBuffer.slice(0, 1024) + '…'
-                : this.thinkingBuffer;
-            await this.sendOrEdit(`<blockquote expandable>💭 Thinking\n${markdownToTelegramHtml(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.
-     *  toolMessages persists across resets — they are independent of the text accumulator. */
+    /** Soft reset: clear per-API-call transient state. Segments and tgMessageId persist across
+     *  tool-use loop iterations within the same turn. */
     softReset() {
-        this.buffer = '';
-        this.thinkingBuffer = '';
-        this.imageBase64Buffer = '';
         this.currentBlockType = null;
-        this.currentToolBlockId = null;
-        this.lastEditTime = 0;
-        this.thinkingIndicatorShown = false;
-        this.finished = false;
+        this.currentBlockId = null;
+        this.currentSegmentIdx = -1;
+        this.sealed = false;
         this.turnUsage = null;
         this._lastMsgStartCtx = null;
-        this.clearEditTimer();
+        this.clearFlushTimer();
+        for (const t of this.toolHideTimers.values())
+            clearTimeout(t);
+        this.toolHideTimers.clear();
     }
-    /** 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. */
+    /** Full reset: clear everything for a new turn. */
     reset() {
         const prevQueue = this.sendQueue;
         this.softReset();
+        this.segments = [];
         this.tgMessageId = null;
         this.messageIds = [];
-        this.sendQueue = prevQueue.catch(() => { }); // swallow errors from prev turn
+        this.toolInputBuffers.clear();
+        this.imageBase64Buffer = '';
+        this.lastEditTime = 0;
+        this.dirty = false;
+        this.flushInFlight = false;
+        this.sendQueue = prevQueue.catch(() => { });
+        this.turnStartTime = Date.now();
+        this.firstSendReady = false;
+        this.clearFirstSendTimer();
+        for (const t of this.toolHideTimers.values())
+            clearTimeout(t);
+        this.toolHideTimers.clear();
+    }
+    clearFlushTimer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
     }
 }
 // ── 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\//, '')
@@ -525,7 +703,6 @@ function shortenPath(p) {
 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'],
@@ -535,22 +712,19 @@ function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireCompl
         Search: ['pattern', 'query'],
         Grep: ['pattern', 'query'],
         Glob: ['pattern'],
-        TodoWrite: [], // handled specially below
-        TaskOutput: [], // handled specially below
+        TodoWrite: [],
+        TaskOutput: [],
     };
     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');
@@ -562,6 +736,14 @@ function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireCompl
             const combined = prefix + label;
             return combined.length > maxLen ? combined.slice(0, maxLen) + '…' : combined;
         }
+        if (toolName === 'Grep' || toolName === 'Search') {
+            const pattern = (parsed.pattern || parsed.query || '').trim();
+            const searchPath = (parsed.path || parsed.glob || '').trim();
+            if (pattern) {
+                const combined = searchPath ? `${pattern} in ${shortenPath(searchPath)}` : pattern;
+                return combined.length > maxLen ? combined.slice(0, maxLen) + '…' : combined;
+            }
+        }
         if (fields) {
             for (const f of fields) {
                 if (typeof parsed[f] === 'string' && parsed[f].trim()) {
@@ -572,7 +754,6 @@ function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireCompl
                 }
             }
         }
-        // Default: first string value
         for (const val of Object.values(parsed)) {
             if (typeof val === 'string' && val.trim()) {
                 const v = val.trim();
@@ -583,11 +764,10 @@ function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireCompl
     }
     catch {
         if (requireComplete)
-            return null; // Only use fully-parsed JSON when requireComplete
-        // Partial JSON — regex extraction (only used for final resolve, not live preview)
+            return null;
         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 re = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`, 'i');
             const m = inputJson.match(re);
             if (m?.[1]) {
                 let val = m[1].replace(/\\n/g, ' ').replace(/\\t/g, '  ').replace(/\\"/g, '"');
@@ -599,9 +779,7 @@ function extractToolInputSummary(toolName, inputJson, maxLen = 120, requireCompl
         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) {
@@ -628,17 +806,13 @@ function extractToolResultStat(toolName, content, toolUseResult) {
     }
     if (toolUseResult && toolName === 'Write') {
         const c = toolUseResult.content;
-        if (c) {
-            const lines = c.split('\n').length;
-            return `${lines} lines`;
-        }
+        if (c)
+            return `${c.split('\n').length} 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`;
@@ -691,25 +865,49 @@ function extractToolResultStat(toolName, content, toolUseResult) {
     }
 }
 function findSplitPoint(text, threshold) {
-    // Try to split at paragraph break
     const paragraphBreak = text.lastIndexOf('\n\n', threshold);
     if (paragraphBreak > threshold * 0.5)
         return paragraphBreak;
-    // Try to split at line break
     const lineBreak = text.lastIndexOf('\n', threshold);
     if (lineBreak > threshold * 0.5)
         return lineBreak;
-    // Try to split at sentence end
     const sentenceEnd = text.lastIndexOf('. ', threshold);
     if (sentenceEnd > threshold * 0.5)
         return sentenceEnd + 2;
-    // Fall back to threshold
     return threshold;
 }
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-/** Format token count as human-readable: 1234 → "1.2k", 500 → "500" */
+function formatElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    const m = Math.floor(s / 60);
+    if (m > 0)
+        return `${m}m ${s % 60}s`;
+    return `${s}s`;
+}
+const MAX_PROGRESS_LINES = 5;
+/** Format a task_progress event into a single HTML-safe progress line.
+ *  Returns null if the event has no useful display content. */
+export function formatProgressLine(description, lastToolName) {
+    const desc = description?.trim();
+    if (!desc)
+        return null;
+    const lower = desc.toLowerCase();
+    const tool = lastToolName?.toLowerCase() ?? '';
+    let emoji = '📋';
+    if (tool === 'bash' && /build|compile|npm run|pnpm|yarn|make/.test(lower)) {
+        emoji = '🔨';
+    }
+    else if (tool === 'bash' && /git commit|git push/.test(lower)) {
+        emoji = '📝';
+    }
+    else if (/context.*%|%.*context|\d{2,3}%/.test(lower)) {
+        emoji = '🧠';
+    }
+    const truncated = desc.length > 60 ? desc.slice(0, 60) + '…' : desc;
+    return `${emoji} ${escapeHtml(truncated)}`;
+}
 function formatTokens(n) {
     if (n >= 1000)
         return (n / 1000).toFixed(1) + 'k';
@@ -717,8 +915,6 @@ function formatTokens(n) {
 }
 /** Format usage stats as an HTML italic footer line */
 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;
@@ -727,7 +923,7 @@ export function formatUsageFooter(usage, _model) {
     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) {
@@ -738,17 +934,14 @@ export function formatUsageFooter(usage, _model) {
 }
 // ── Sub-agent detection patterns ──
 const CC_SUB_AGENT_TOOLS = new Set([
-    'Task', // Primary CC spawning tool
-    'dispatch_agent', // Legacy/alternative tool
-    'create_agent', // Test compatibility
-    'AgentRunner' // Test compatibility
+    'Task',
+    'dispatch_agent',
+    'create_agent',
+    'AgentRunner'
 ]);
 export function isSubAgentTool(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);
@@ -758,7 +951,6 @@ export function extractSubAgentSummary(jsonInput, maxLen = 150) {
         }
     }
     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);
@@ -770,22 +962,15 @@ 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
+        return LABEL_FIELDS.length + 1;
     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.
- * Returns { label, field } so callers can track priority and upgrade labels
- * when higher-priority fields become available during streaming.
- */
 export function extractAgentLabel(jsonInput) {
-    const summaryField = 'prompt'; // last resort — first line of prompt
+    const summaryField = 'prompt';
     try {
         const parsed = JSON.parse(jsonInput);
         for (const key of LABEL_FIELDS) {
@@ -802,13 +987,10 @@ export function extractAgentLabel(jsonInput) {
         return { label: '', field: null };
     }
     catch {
-        // JSON incomplete during streaming — extract first complete field value
         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.
- *  Returns { label, field } so callers know which field matched. */
 function extractFieldFromPartialJsonWithField(input, keys) {
     for (const key of keys) {
         const idx = input.indexOf(`"${key}"`);
@@ -821,7 +1003,6 @@ function extractFieldFromPartialJsonWithField(input, keys) {
         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) {
@@ -844,9 +1025,9 @@ function extractFieldFromPartialJsonWithField(input, keys) {
 export class SubAgentTracker {
     chatId;
     sender;
-    agents = new Map(); // toolUseId → info
-    blockToAgent = new Map(); // blockIndex → toolUseId
-    consolidatedAgentMsgId = null; // shared TG message for all sub-agents
+    agents = new Map();
+    blockToAgent = new Map();
+    standaloneMsgId = null; // post-turn standalone status bubble
     sendQueue = Promise.resolve();
     teamName = null;
     mailboxPath = null;
@@ -854,6 +1035,9 @@ export class SubAgentTracker {
     lastMailboxCount = 0;
     onAllReported = null;
     hasPendingFollowUp = false;
+    /** When true, stream events update agent metadata but do NOT create TG messages.
+     *  Set to false after the main turn bubble is sealed to allow standalone status bubble. */
+    inTurn = true;
     constructor(options) {
         this.chatId = options.chatId;
         this.sender = options.sender;
@@ -861,32 +1045,41 @@ export class SubAgentTracker {
     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.
-     */
+    /** Called after the main bubble is sealed. Creates standalone status bubble for any dispatched agents. */
+    async startPostTurnTracking() {
+        this.inTurn = false;
+        if (!this.hasDispatchedAgents)
+            return;
+        // Create the standalone status bubble
+        const html = this.buildStandaloneHtml();
+        this.sendQueue = this.sendQueue.then(async () => {
+            try {
+                const msgId = await this.sender.sendMessage(this.chatId, html, 'HTML');
+                this.standaloneMsgId = msgId;
+                // Set tgMessageId on all dispatched agents pointing to this standalone bubble
+                for (const info of this.agents.values()) {
+                    if (info.status === 'dispatched') {
+                        info.tgMessageId = msgId;
+                    }
+                }
+            }
+            catch {
+                // Non-critical
+            }
+        }).catch(() => { });
+        await this.sendQueue;
+    }
     markDispatchedAsReportedInMain() {
         for (const [, info] of this.agents) {
-            if (info.status !== 'dispatched' || !info.tgMessageId)
+            if (info.status !== 'dispatched')
                 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 (err) {
-                    // Non-critical — edit failure on dispatched agent status
-                }
-            }).catch(() => { });
         }
     }
     async handleEvent(event) {
@@ -904,12 +1097,8 @@ export class SubAgentTracker {
             case 'content_block_stop':
                 await this.onBlockStop(event);
                 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)
@@ -917,13 +1106,13 @@ export class SubAgentTracker {
         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
+        if (!this.inTurn)
+            this.updateStandaloneMessage();
         const allDone = ![...this.agents.values()].some(a => a.status === 'dispatched');
         if (allDone && this.onAllReported) {
             this.onAllReported();
@@ -932,44 +1121,27 @@ export class SubAgentTracker {
     }
     async handleToolResult(toolUseId, result) {
         const info = this.agents.get(toolUseId);
-        if (!info || !info.tgMessageId)
+        if (!info)
             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();
-            this.updateConsolidatedAgentMessage();
+            if (!this.inTurn)
+                this.updateStandaloneMessage();
             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 {
-                // Edit failure on tool result — non-critical
-            }
-        }).catch(() => { });
-        await this.sendQueue;
+        if (!this.inTurn)
+            this.updateStandaloneMessage();
     }
     async onBlockStart(event) {
         if (event.content_block.type !== 'tool_use')
@@ -987,64 +1159,26 @@ export class SubAgentTracker {
             labelField: null,
             agentName: '',
             inputPreview: '',
+            startTime: Date.now(),
             dispatchedAt: null,
+            progressLines: [],
         };
         this.agents.set(block.id, info);
         this.blockToAgent.set(event.index, block.id);
-        // Consolidate all sub-agent indicators into one shared message.
-        // If a consolidated message already exists, reuse it; otherwise create one.
-        if (this.consolidatedAgentMsgId) {
-            info.tgMessageId = this.consolidatedAgentMsgId;
-            this.updateConsolidatedAgentMessage();
-        }
-        else {
-            this.sendQueue = this.sendQueue.then(async () => {
-                try {
-                    const msgId = await this.sender.sendMessage(this.chatId, '🤖 Starting sub-agent…', 'HTML');
-                    info.tgMessageId = msgId;
-                    this.consolidatedAgentMsgId = msgId;
-                }
-                catch {
-                    // Sub-agent indicator is non-critical
-                }
-            }).catch(() => { });
-            await this.sendQueue;
-        }
-    }
-    /** Build and edit the shared sub-agent status message. */
-    updateConsolidatedAgentMessage() {
-        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;
-            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 {
-                // Consolidated message edit failure — non-critical
-            }
-        }).catch(() => { });
+        // During the turn, StreamAccumulator renders the sub-agent segment.
+        // Tracker only manages metadata here (no TG message).
     }
     async onInputDelta(event) {
         const toolUseId = this.blockToAgent.get(event.index);
         if (!toolUseId)
             return;
         const info = this.agents.get(toolUseId);
-        if (!info || !info.tgMessageId)
+        if (!info)
             return;
         if (info.inputPreview.length < 10_000) {
             info.inputPreview += event.delta.partial_json;
         }
-        // Extract agent name from input JSON (used for mailbox matching)
+        // Extract agent name for mailbox matching
         if (!info.agentName) {
             try {
                 const parsed = JSON.parse(info.inputPreview);
@@ -1053,19 +1187,16 @@ export class SubAgentTracker {
                 }
             }
             catch {
-                // Partial JSON — try extracting name field
                 const nameMatch = info.inputPreview.match(/"name"\s*:\s*"([^"]+)"/);
                 if (nameMatch)
                     info.agentName = nameMatch[1];
             }
         }
-        // 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")
+        // Extract label for standalone bubble (used post-turn)
         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) {
@@ -1073,56 +1204,41 @@ export class SubAgentTracker {
         if (!toolUseId)
             return;
         const info = this.agents.get(toolUseId);
-        if (!info || !info.tgMessageId)
+        if (!info)
             return;
-        // 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 (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
     }
-    /** 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) {
+        if (this.mailboxWatching)
             return;
-        }
-        if (!this.mailboxPath) {
+        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;
@@ -1132,7 +1248,6 @@ export class SubAgentTracker {
         catch { /* ignore */ }
         this.mailboxWatching = false;
     }
-    /** Read and parse the mailbox file. Returns [] on any error. */
     readMailboxMessages() {
         if (!this.mailboxPath || !existsSync(this.mailboxPath))
             return [];
@@ -1145,7 +1260,6 @@ export class SubAgentTracker {
             return [];
         }
     }
-    /** Process new mailbox messages and update sub-agent TG messages. */
     processMailbox() {
         const messages = this.readMailboxMessages();
         if (messages.length <= this.lastMailboxCount)
@@ -1153,64 +1267,60 @@ export class SubAgentTracker {
         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 {
-                    // Reaction failure — non-critical, might not be supported
-                }
-            }).catch(() => { });
+            // Update standalone bubble or set reaction on its message
+            if (!this.inTurn && this.standaloneMsgId) {
+                this.updateStandaloneMessage();
+                // Also react on the standalone bubble
+                const msgId = this.standaloneMsgId;
+                const emoji = msg.color === 'red' ? '👎' : '👍';
+                this.sendQueue = this.sendQueue.then(async () => {
+                    try {
+                        await this.sender.setReaction?.(this.chatId, msgId, emoji);
+                    }
+                    catch { /* non-critical */ }
+                }).catch(() => { });
+            }
+            else if (matched.tgMessageId) {
+                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 { /* non-critical */ }
+                }).catch(() => { });
+            }
         }
-        // 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) {
+            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)) {
+            if (label === fromLower || label.includes(fromLower) || fromLower.includes(label))
                 return info;
-            }
         }
         return null;
     }
-    /** Handle a system task_started event — update the sub-agent status display. */
-    handleTaskStarted(toolUseId, description, taskType) {
+    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';
@@ -1218,84 +1328,86 @@ export class SubAgentTracker {
         info.status = 'dispatched';
         if (!info.dispatchedAt)
             info.dispatchedAt = Date.now();
-        this.updateConsolidatedAgentMessage();
+        if (!this.inTurn)
+            this.updateStandaloneMessage();
     }
-    /** 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)
+        if (!info || info.status === 'completed')
             return;
-        if (info.status === 'completed')
-            return; // Don't update completed agents
-        // Update the consolidated message with progress info
-        this.updateConsolidatedAgentMessageWithProgress(toolUseId, description, lastToolName);
+        const line = formatProgressLine(description, lastToolName);
+        if (line) {
+            info.progressLines.push(line);
+            if (info.progressLines.length > MAX_PROGRESS_LINES)
+                info.progressLines.shift();
+        }
+        if (!this.inTurn)
+            this.updateStandaloneMessage();
     }
-    /** 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
+        if (!this.inTurn)
+            this.updateStandaloneMessage();
         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 = [];
+    /** Build the standalone status bubble HTML. */
+    buildStandaloneHtml() {
+        const entries = [];
         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}`);
+            const elapsed = formatElapsed(Date.now() - info.startTime);
+            let statusLine;
+            if (info.status === 'completed') {
+                statusLine = `🤖 ${escapeHtml(label)} — ✅ Done (${elapsed})`;
             }
             else {
-                const status = info.status === 'completed' ? '✅ Done'
-                    : info.status === 'dispatched' ? 'Waiting for results…'
-                        : 'Working…';
-                lines.push(`🤖 ${escapeHtml(label)} — ${status}`);
+                statusLine = `🤖 ${escapeHtml(label)} — Working (${elapsed})…`;
             }
+            const progressBlock = info.progressLines.length > 0
+                ? '\n' + info.progressLines.join('\n')
+                : '';
+            entries.push(statusLine + progressBlock);
         }
-        const text = lines.join('\n');
+        return `<blockquote>${entries.join('\n\n')}</blockquote>`;
+    }
+    /** Edit the standalone status bubble with current state. */
+    updateStandaloneMessage() {
+        if (!this.standaloneMsgId)
+            return;
+        const msgId = this.standaloneMsgId;
+        const html = this.buildStandaloneHtml();
         this.sendQueue = this.sendQueue.then(async () => {
             try {
-                await this.sender.editMessage(this.chatId, msgId, text, 'HTML');
-            }
-            catch {
-                // Progress message edit failure — non-critical
+                await this.sender.editMessage(this.chatId, msgId, html, 'HTML');
             }
+            catch { /* 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();
-        // Clear all elapsed timers before resetting
-        for (const info of this.agents.values()) {
-        }
         this.agents.clear();
         this.blockToAgent.clear();
-        this.consolidatedAgentMsgId = null;
+        this.standaloneMsgId = null;
         this.sendQueue = Promise.resolve();
         this.teamName = null;
         this.mailboxPath = null;
         this.lastMailboxCount = 0;
         this.onAllReported = null;
+        this.inTurn = true;
     }
 }
 // ── 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 = [];