remoat 0.2.9 → 0.2.10

package/dist/bot/index.js

@@ -27,9 +27,9 @@ const antigravityLauncher_1 = require("../services/antigravityLauncher");
 const pathUtils_1 = require("../utils/pathUtils");
 const promptDispatcher_1 = require("../services/promptDispatcher");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
-const streamMessageFormatter_1 = require("../utils/streamMessageFormatter");
+const assistantDomExtractor_1 = require("../services/assistantDomExtractor");
 const telegramFormatter_1 = require("../utils/telegramFormatter");
-const processLogBuffer_1 = require("../utils/processLogBuffer");
+// ProcessLogBuffer no longer used — progress display uses ordered event stream
 const imageHandler_1 = require("../utils/imageHandler");
 const voiceHandler_1 = require("../utils/voiceHandler");
 const modeUi_1 = require("../ui/modeUi");
@@ -69,7 +69,7 @@ function stripHtmlForFile(html) {
     // Links
     text = text.replace(/<a\s+href="([^"]*)">([\s\S]*?)<\/a>/gi, '[$2]($1)');
     // Blockquotes
-    text = text.replace(/<blockquote>([\s\S]*?)<\/blockquote>/gi, (_m, content) => content.split('\n').map((l) => `> ${l}`).join('\n'));
+    text = text.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_m, content) => content.split('\n').map((l) => `> ${l}`).join('\n'));
     // Strip remaining tags
     text = text.replace(/<[^>]+>/g, '');
     // Decode entities
@@ -142,7 +142,9 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
     /** Send a potentially long response, splitting into chunks and attaching a .md file if needed. */
     const sendChunkedResponse = async (title, footer, rawBody, isAlreadyHtml) => {
         const formattedBody = isAlreadyHtml ? rawBody : (0, telegramFormatter_1.formatForTelegram)(rawBody);
-        const fullMsg = `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${formattedBody}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
+        const titleLine = title ? `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n` : '';
+        const footerLine = footer ? `\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>` : '';
+        const fullMsg = `${titleLine}${formattedBody}${footerLine}`;
         if (fullMsg.length <= TELEGRAM_MSG_LIMIT) {
             await upsertLiveResponse(title, rawBody, footer, { expectedVersion: liveResponseUpdateVersion, isAlreadyHtml, skipTruncation: true });
             return;
@@ -154,10 +156,12 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
         for (let pi = 0; pi < inlineCount; pi++) {
             const partLabel = hasFile ? `(${pi + 1}/${inlineCount}+file)` : `(${pi + 1}/${total})`;
             if (pi === 0) {
-                await upsertLiveResponse(`${title} ${partLabel}`, bodyChunks[pi], footer, { expectedVersion: liveResponseUpdateVersion, isAlreadyHtml: true, skipTruncation: true });
+                const firstTitle = title ? `${title} ${partLabel}` : partLabel;
+                await upsertLiveResponse(firstTitle, bodyChunks[pi], footer, { expectedVersion: liveResponseUpdateVersion, isAlreadyHtml: true, skipTruncation: true });
             }
             else {
-                await sendMsg(`${bodyChunks[pi]}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)} ${partLabel}</i>`);
+                const partFooter = footer ? `${(0, telegramFormatter_1.escapeHtml)(footer)} ${partLabel}` : partLabel;
+                await sendMsg(`${bodyChunks[pi]}\n\n<i>${partFooter}</i>`);
             }
         }
         if (hasFile) {
@@ -182,60 +186,102 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
     const localMode = modeService.getCurrentMode();
     const modeName = modeService_1.MODE_UI_NAMES[localMode] || localMode;
     const currentModel = (await cdp.getCurrentModel()) || modelService.getCurrentModel();
-    await sendEmbed(`${PHASE_ICONS.sending} [${modeName} - ${currentModel}] Sending...`, (0, streamMessageFormatter_1.buildModeModelLines)(modeName, currentModel, currentModel).join('\n'));
+    const modelLabel = `${currentModel}`;
+    // Initialize live progress message (replaces separate "Sending" embed)
+    let liveActivityMsgId = null;
+    try {
+        const sendingText = `<b>${PHASE_ICONS.sending} ${(0, telegramFormatter_1.escapeHtml)(modeName)} · ${(0, telegramFormatter_1.escapeHtml)(modelLabel)}</b>\n\n<i>Sending...</i>`;
+        const sendingMsg = await api.sendMessage(channel.chatId, sendingText, { parse_mode: 'HTML', message_thread_id: channel.threadId });
+        liveActivityMsgId = sendingMsg.message_id;
+    }
+    catch (e) {
+        logger_1.logger.error('[sendPrompt] Failed to send initial status:', e);
+    }
     let isFinalized = false;
     let elapsedTimer = null;
     let lastProgressText = '';
-    let lastActivityLogText = '';
-    let lastThinkingLogText = '';
     const LIVE_RESPONSE_MAX_LEN = 3800;
-    const LIVE_ACTIVITY_MAX_LEN = 3800;
-    const THINKING_BUDGET = 1500;
-    const ACTIVITY_BUDGET = 2300;
-    const processLogBuffer = new processLogBuffer_1.ProcessLogBuffer({ maxChars: LIVE_ACTIVITY_MAX_LEN, maxEntries: 120, maxEntryLength: 220 });
+    const MAX_PROGRESS_BODY = 3500;
+    const MAX_PROGRESS_ENTRIES = 60;
     let liveResponseMsgId = null;
-    let liveActivityMsgId = null;
     let lastLiveResponseKey = '';
     let lastLiveActivityKey = '';
     let liveResponseUpdateVersion = 0;
     let liveActivityUpdateVersion = 0;
-    const ACTIVITY_PLACEHOLDER = (0, i18n_1.t)('Collecting process logs...');
+    const progressLog = [];
+    let thinkingActive = false;
+    const thinkingContentParts = [];
+    let lastThoughtLabel = '';
+    /** Check if text is junk (numbers, very short, not meaningful) */
+    const isJunkEntry = (text) => {
+        const t = text.trim();
+        if (t.length < 5)
+            return true;
+        if (/^\d+$/.test(t))
+            return true;
+        // Single word under 8 chars without context (e.g. "Analyzed" alone)
+        if (!/\s/.test(t) && t.length < 8)
+            return true;
+        return false;
+    };
+    /** Format a single activity line — collapse multi-line text into one line */
+    const formatActivityLine = (raw) => {
+        // Collapse newlines into spaces so file references after verbs aren't lost
+        // e.g. "Analyzed\npackage.json#L1-75" → "Analyzed package.json#L1-75"
+        const collapsed = (raw || '').replace(/\n+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+        if (!collapsed || isJunkEntry(collapsed))
+            return '';
+        return (0, telegramFormatter_1.escapeHtml)(collapsed.slice(0, 120));
+    };
+    /** Trim progress log to stay within size limits */
+    const trimProgressLog = () => {
+        while (progressLog.length > MAX_PROGRESS_ENTRIES)
+            progressLog.shift();
+    };
+    /** Build the progress message body from the ordered event stream */
+    const buildProgressBody = () => {
+        const lines = [];
+        for (const e of progressLog) {
+            switch (e.kind) {
+                case 'thought':
+                    lines.push(`💭 <i>${(0, telegramFormatter_1.escapeHtml)(e.text)}</i>`);
+                    break;
+                case 'thought-content':
+                    lines.push(`<i>${(0, telegramFormatter_1.escapeHtml)(e.text)}</i>`);
+                    break;
+                case 'activity':
+                    lines.push(e.text); // already HTML-escaped
+                    break;
+            }
+        }
+        if (thinkingActive) {
+            lines.push('💭 <i>Thinking...</i>');
+        }
+        // Use \n\n for spacing between entries (like Antigravity's line gap)
+        let body = lines.join('\n\n');
+        // Trim from beginning if too long, keeping most recent events
+        if (body.length > MAX_PROGRESS_BODY) {
+            body = '...\n\n' + body.slice(-MAX_PROGRESS_BODY + 5);
+        }
+        return body || '<i>Generating...</i>';
+    };
+    /** Build full progress message with title + body + footer */
+    const buildProgressMessage = (title, footer) => {
+        const body = buildProgressBody();
+        const footerLine = footer ? `\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>` : '';
+        return `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${body}${footerLine}`;
+    };
     const buildLiveResponseText = (title, rawText, footer, isAlreadyHtml = false, skipTruncation = false) => {
         const normalized = (rawText || '').trim();
         const body = normalized
             ? (isAlreadyHtml ? normalized : (0, telegramFormatter_1.formatForTelegram)(normalized))
-            : (0, i18n_1.t)('Waiting for output...');
+            : (0, i18n_1.t)('Generating...');
         const truncated = (!skipTruncation && body.length > LIVE_RESPONSE_MAX_LEN)
             ? '...(beginning truncated)\n' + body.slice(-LIVE_RESPONSE_MAX_LEN + 30)
             : body;
-        return `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${truncated}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
-    };
-    const buildLiveActivityText = (title, rawText, footer) => {
-        const normalized = (rawText || '').trim();
-        const thinkingNormalized = (lastThinkingLogText || '').trim();
-        const hasThinking = thinkingNormalized.length > 10;
-        let body;
-        if (hasThinking) {
-            const thinkingTruncated = thinkingNormalized.length > THINKING_BUDGET
-                ? '...' + thinkingNormalized.slice(-THINKING_BUDGET + 3)
-                : thinkingNormalized;
-            const activityBody = normalized
-                ? (0, streamMessageFormatter_1.fitForSingleEmbedDescription)((0, telegramFormatter_1.formatForTelegram)(normalized), ACTIVITY_BUDGET)
-                : ACTIVITY_PLACEHOLDER;
-            body = `\u{1F9E0} <b>AI Thinking</b>\n<blockquote>${(0, telegramFormatter_1.escapeHtml)(thinkingTruncated)}</blockquote>\n\n\u{1F4CB} <b>Activity</b>\n${activityBody}`;
-        }
-        else {
-            body = normalized
-                ? (0, streamMessageFormatter_1.fitForSingleEmbedDescription)((0, telegramFormatter_1.formatForTelegram)(normalized), LIVE_ACTIVITY_MAX_LEN)
-                : ACTIVITY_PLACEHOLDER;
-        }
-        return `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${body}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
-    };
-    const appendProcessLogs = (text) => {
-        const normalized = (text || '').trim();
-        if (!normalized)
-            return processLogBuffer.snapshot();
-        return processLogBuffer.append(normalized);
+        const titleLine = title ? `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n` : '';
+        const footerLine = footer ? `\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>` : '';
+        return `${titleLine}${truncated}${footerLine}`;
     };
     const upsertLiveResponse = (title, rawText, footer, opts) => enqueueResponse(async () => {
         if (opts?.skipWhenFinalized && isFinalized)
@@ -254,16 +300,18 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
             liveResponseMsgId = await sendMsg(text);
         }
     }, 'upsert-response');
-    const upsertLiveActivity = (title, rawText, footer, opts) => enqueueActivity(async () => {
+    /** Refresh progress message using the ordered event stream */
+    const refreshProgress = (title, footer, opts) => enqueueActivity(async () => {
         if (opts?.skipWhenFinalized && isFinalized)
             return;
         if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveActivityUpdateVersion)
             return;
-        const text = buildLiveActivityText(title, rawText, footer);
-        const renderKey = `${title}|${rawText.slice(0, 200)}|${footer}`;
-        if (renderKey === lastLiveActivityKey && liveActivityMsgId)
+        const text = buildProgressMessage(title, footer);
+        // Use progress body hash for dedup
+        const bodySnap = progressLog.length + '|' + thinkingActive + '|' + title + '|' + footer;
+        if (bodySnap === lastLiveActivityKey && liveActivityMsgId)
             return;
-        lastLiveActivityKey = renderKey;
+        lastLiveActivityKey = bodySnap;
         if (liveActivityMsgId) {
             await editMsg(liveActivityMsgId, text);
         }
@@ -271,6 +319,18 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
             liveActivityMsgId = await sendMsg(text);
         }
     }, 'upsert-activity');
+    /** Direct message update for special cases (completion, quota, timeout) */
+    const setProgressMessage = (htmlContent, opts) => enqueueActivity(async () => {
+        if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveActivityUpdateVersion)
+            return;
+        lastLiveActivityKey = htmlContent.slice(0, 200);
+        if (liveActivityMsgId) {
+            await editMsg(liveActivityMsgId, htmlContent);
+        }
+        else {
+            liveActivityMsgId = await sendMsg(htmlContent);
+        }
+    }, 'upsert-activity');
     const sendGeneratedImages = async (responseText) => {
         const imageIntentPattern = /(image|images|png|jpg|jpeg|gif|webp|illustration|diagram|render)/i;
         const imageUrlPattern = /https?:\/\/\S+\.(png|jpg|jpeg|gif|webp)/i;
@@ -338,7 +398,15 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
             return;
         }
         const startTime = Date.now();
-        await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, '', (0, i18n_1.t)('⏱️ Elapsed: 0s | Process log'));
+        const progressTitle = () => `${PHASE_ICONS.thinking} ${modelLabel}`;
+        const progressFooter = () => `⏱️ ${Math.round((Date.now() - startTime) / 1000)}s`;
+        /** Trigger a progress message refresh */
+        const triggerProgressRefresh = () => {
+            liveActivityUpdateVersion += 1;
+            const v = liveActivityUpdateVersion;
+            refreshProgress(progressTitle(), progressFooter(), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+        };
+        await refreshProgress(progressTitle(), progressFooter());
         monitor = new responseMonitor_1.ResponseMonitor({
             cdpService: cdp,
             pollIntervalMs: 2000,
@@ -348,27 +416,59 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
             onProcessLog: (logText) => {
                 if (isFinalized)
                     return;
-                if (logText && logText.trim().length > 0)
-                    lastActivityLogText = appendProcessLogs(logText);
-                const elapsed = Math.round((Date.now() - startTime) / 1000);
-                liveActivityUpdateVersion += 1;
-                const v = liveActivityUpdateVersion;
-                upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+                const trimmed = (logText || '').trim();
+                if (!trimmed || isJunkEntry(trimmed))
+                    return;
+                const formatted = formatActivityLine(trimmed);
+                if (formatted) {
+                    progressLog.push({ kind: 'activity', text: formatted });
+                    trimProgressLog();
+                    triggerProgressRefresh();
+                }
             },
             onThinkingLog: (thinkingText) => {
                 if (isFinalized)
                     return;
-                logger_1.logger.debug('[Bot] onThinkingLog received:', (thinkingText || '').slice(0, 100));
-                if (thinkingText && thinkingText.trim().length > 0) {
-                    lastThinkingLogText = lastThinkingLogText
-                        ? lastThinkingLogText + '\n' + thinkingText.trim()
-                        : thinkingText.trim();
-                    logger_1.logger.debug('[Bot] lastThinkingLogText now:', lastThinkingLogText.length, 'chars');
+                const trimmed = (thinkingText || '').trim();
+                if (!trimmed)
+                    return;
+                logger_1.logger.debug('[Bot] onThinkingLog received:', trimmed.slice(0, 100));
+                const stripped = trimmed.replace(/^[^a-zA-Z]+/, '');
+                if (/^thinking\.{0,3}$/i.test(stripped)) {
+                    // Transient "Thinking..." — just set flag, don't add entry
+                    thinkingActive = true;
+                }
+                else if (/^thought for\s/i.test(stripped)) {
+                    // Completed thinking cycle: "Thought for 1s"
+                    thinkingActive = false;
+                    lastThoughtLabel = trimmed;
+                    progressLog.push({ kind: 'thought', text: trimmed });
+                    trimProgressLog();
                 }
-                const elapsed = Math.round((Date.now() - startTime) / 1000);
-                liveActivityUpdateVersion += 1;
-                const v = liveActivityUpdateVersion;
-                upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+                else {
+                    // Thinking content — merge as summary with most recent 'thought' entry
+                    thinkingContentParts.push(trimmed);
+                    const firstLine = trimmed.split('\n')[0].trim();
+                    const heading = firstLine.length > 60 ? firstLine.slice(0, 57) + '...' : firstLine;
+                    // Find most recent thought entry that doesn't yet have content attached
+                    let merged = false;
+                    for (let i = progressLog.length - 1; i >= 0; i--) {
+                        if (progressLog[i].kind === 'thought') {
+                            // Only merge if no content heading attached yet (no " — ")
+                            if (!progressLog[i].text.includes(' — ')) {
+                                progressLog[i].text += ` — ${heading}`;
+                                merged = true;
+                            }
+                            break;
+                        }
+                    }
+                    if (!merged && heading.length > 10) {
+                        // No thought label to merge into — show as standalone content
+                        progressLog.push({ kind: 'thought-content', text: heading });
+                        trimProgressLog();
+                    }
+                }
+                triggerProgressRefresh();
             },
             onProgress: (text) => {
                 if (isFinalized)
@@ -396,11 +496,11 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
                     const elapsed = Math.round((Date.now() - startTime) / 1000);
                     const isQuotaError = monitor.getPhase() === 'quotaReached' || monitor.getQuotaDetected();
                     if (isQuotaError) {
-                        const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
                         liveActivityUpdateVersion += 1;
-                        await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, finalLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                        thinkingActive = false;
+                        await setProgressMessage(`<b>⚠️ ${(0, telegramFormatter_1.escapeHtml)(modelLabel)} · Quota Reached</b>\n\n${buildProgressBody()}\n\n<i>⏱️ ${elapsed}s</i>`, { expectedVersion: liveActivityUpdateVersion });
                         liveResponseUpdateVersion += 1;
-                        await upsertLiveResponse('⚠️ Model Quota Reached', 'Model quota limit reached. Please wait or switch to a different model.', (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Quota Reached`), { expectedVersion: liveResponseUpdateVersion });
+                        await upsertLiveResponse('⚠️ Quota Reached', 'Model quota limit reached. Please wait or switch to a different model.', `⏱️ ${elapsed}s`, { expectedVersion: liveResponseUpdateVersion });
                         try {
                             const payload = await (0, modelsUi_1.buildModelsUI)(cdp, () => bridge.quota.fetchQuota());
                             if (payload) {
@@ -412,32 +512,137 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
                         }
                         return;
                     }
-                    const responseText = (finalText && finalText.trim().length > 0) ? finalText : lastProgressText;
-                    const emergencyText = (!responseText || responseText.trim().length === 0) ? await tryEmergencyExtractText() : '';
-                    const finalResponseText = responseText && responseText.trim().length > 0 ? responseText : emergencyText;
-                    const isAlreadyHtml = meta?.source === 'structured';
+                    // Fresh DOM re-extraction at completion time to ensure we get the
+                    // complete response — polling may have captured partial/stale text.
+                    let freshText = '';
+                    let freshIsHtml = false;
+                    try {
+                        const contextId = cdp.getPrimaryContextId();
+                        const evalParams = {
+                            expression: (0, assistantDomExtractor_1.extractAssistantSegmentsPayloadScript)(),
+                            returnByValue: true,
+                            awaitPromise: true,
+                        };
+                        if (contextId !== null && contextId !== undefined)
+                            evalParams.contextId = contextId;
+                        const freshResult = await cdp.call('Runtime.evaluate', evalParams);
+                        const freshClassified = (0, assistantDomExtractor_1.classifyAssistantSegments)(freshResult?.result?.value);
+                        if (freshClassified.diagnostics.source === 'dom-structured' && freshClassified.finalOutputText.trim()) {
+                            freshText = freshClassified.finalOutputText.trim();
+                            freshIsHtml = true;
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.debug('[onComplete] Fresh structured extraction failed:', e);
+                    }
+                    // Pick the best text: fresh extraction > polled finalText > lastProgressText > emergency
+                    const polledText = (finalText && finalText.trim().length > 0) ? finalText : lastProgressText;
+                    const bestPolled = polledText && polledText.trim().length > 0 ? polledText : '';
+                    // Prefer the fresh extraction if it's at least as long (more complete)
+                    let finalResponseText;
+                    let isAlreadyHtml;
+                    if (freshText && freshText.length >= bestPolled.length) {
+                        finalResponseText = freshText;
+                        isAlreadyHtml = freshIsHtml;
+                    }
+                    else if (bestPolled) {
+                        finalResponseText = bestPolled;
+                        isAlreadyHtml = meta?.source === 'structured';
+                    }
+                    else {
+                        const emergencyText = await tryEmergencyExtractText();
+                        finalResponseText = emergencyText;
+                        isAlreadyHtml = false;
+                    }
                     const separated = isAlreadyHtml ? { output: finalResponseText, logs: '' } : (0, telegramFormatter_1.splitOutputAndLogs)(finalResponseText);
                     const finalOutputText = separated.output || finalResponseText;
-                    const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
-                    if (finalLogText && finalLogText.trim().length > 0) {
-                        logger_1.logger.divider('Process Log');
-                        console.info(finalLogText);
+                    // Send collapsible thinking block as a separate message before the response.
+                    // Extract both label and content directly from DOM at completion time,
+                    // so we don't depend on polling (2s interval) having captured thinking events.
+                    try {
+                        const thinkExtract = await cdp.call('Runtime.evaluate', {
+                            expression: `(function() {
+                                var panel = document.querySelector('.antigravity-agent-side-panel');
+                                var scope = panel || document;
+                                var details = scope.querySelectorAll('details');
+                                var blocks = [];
+                                for (var i = 0; i < details.length; i++) {
+                                    var d = details[i];
+                                    var summary = d.querySelector('summary');
+                                    if (!summary) continue;
+                                    var rawLabel = (summary.textContent || '').trim();
+                                    var stripped = rawLabel.replace(/^[^a-zA-Z]+/, '');
+                                    if (!/^(?:thought for|thinking)\\b/i.test(stripped)) continue;
+                                    var wasOpen = d.open;
+                                    if (!wasOpen) d.open = true;
+                                    // Try children first, then fall back to full textContent minus summary
+                                    var children = d.children;
+                                    var parts = [];
+                                    for (var c = 0; c < children.length; c++) {
+                                        if (children[c].tagName === 'SUMMARY' || children[c].tagName === 'STYLE') continue;
+                                        var t = (children[c].innerText || children[c].textContent || '').trim();
+                                        if (t && t.length >= 5) parts.push(t);
+                                    }
+                                    // Fallback: use detail's full text minus the summary text
+                                    if (parts.length === 0) {
+                                        var fullText = (d.innerText || d.textContent || '').trim();
+                                        var bodyText = fullText.replace(rawLabel, '').trim();
+                                        if (bodyText && bodyText.length >= 5) parts.push(bodyText);
+                                    }
+                                    if (!wasOpen) d.open = false;
+                                    blocks.push({ label: rawLabel, body: parts.join('\\n\\n') });
+                                }
+                                return blocks;
+                            })()`,
+                            returnByValue: true,
+                        });
+                        const thinkBlocks = Array.isArray(thinkExtract?.result?.value) ? thinkExtract.result.value : [];
+                        if (thinkBlocks.length > 0) {
+                            // Also incorporate poll-accumulated content if available
+                            const accumulatedBody = thinkingContentParts.join('\n\n');
+                            // Build combined thinking message — merge all blocks
+                            const sections = [];
+                            for (const block of thinkBlocks) {
+                                const label = block.label || lastThoughtLabel || 'Thinking';
+                                const body = block.body || accumulatedBody || '';
+                                if (body) {
+                                    sections.push(`  💭 <b>${(0, telegramFormatter_1.escapeHtml)(label)}</b>\n\n<i>${(0, telegramFormatter_1.escapeHtml)(body)}</i>`);
+                                }
+                                else {
+                                    sections.push(`  💭 <b>${(0, telegramFormatter_1.escapeHtml)(label)}</b>`);
+                                }
+                            }
+                            const combined = sections.join('\n\n');
+                            const maxThinkLen = TELEGRAM_MSG_LIMIT - 100;
+                            const trimmed = combined.length > maxThinkLen ? combined.slice(0, maxThinkLen) + '...' : combined;
+                            const thinkMsg = `<blockquote expandable>${trimmed}</blockquote>`;
+                            logger_1.logger.info(`[Bot] Sending thinking block: ${thinkBlocks.length} block(s), ${combined.length} chars`);
+                            await sendMsg(thinkMsg);
+                        }
+                        else {
+                            logger_1.logger.info('[Bot] No thinking blocks found in DOM at completion time');
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.error('[Bot] Failed to send thinking block:', e);
                     }
                     if (finalOutputText && finalOutputText.trim().length > 0) {
                         logger_1.logger.divider(`Output (${finalOutputText.length} chars)`);
                         console.info(finalOutputText);
                     }
                     logger_1.logger.divider();
+                    // Compact progress message: show completed title + event log
                     liveActivityUpdateVersion += 1;
-                    await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, finalLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                    thinkingActive = false;
+                    const completedBody = buildProgressBody();
+                    await setProgressMessage(`<b>${PHASE_ICONS.complete} ${(0, telegramFormatter_1.escapeHtml)(modelLabel)} · ${elapsed}s</b>\n\n${completedBody}`, { expectedVersion: liveActivityUpdateVersion });
                     liveResponseUpdateVersion += 1;
                     if (finalOutputText && finalOutputText.trim().length > 0) {
-                        const title = `${PHASE_ICONS.complete} Final Output`;
-                        const footer = (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`);
-                        await sendChunkedResponse(title, footer, finalOutputText, isAlreadyHtml);
+                        const footer = `⏱️ ${elapsed}s`;
+                        await sendChunkedResponse('', footer, finalOutputText, isAlreadyHtml);
                     }
                     else {
-                        await upsertLiveResponse(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use /screenshot to verify.'), (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), { expectedVersion: liveResponseUpdateVersion });
+                        await upsertLiveResponse(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use /screenshot to verify.'), `⏱️ ${elapsed}s`, { expectedVersion: liveResponseUpdateVersion });
                     }
                     if (options) {
                         try {
@@ -489,16 +694,14 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
                     const timeoutText = (lastText && lastText.trim().length > 0) ? lastText : lastProgressText;
                     const timeoutIsHtml = monitor.getLastExtractionSource() === 'structured';
                     const separated = timeoutIsHtml ? { output: timeoutText || '', logs: '' } : (0, telegramFormatter_1.splitOutputAndLogs)(timeoutText || '');
-                    const sanitizedTimeoutLogs = lastActivityLogText || processLogBuffer.snapshot();
                     const payload = separated.output && separated.output.trim().length > 0
                         ? `${separated.output}\n\n[Monitor Ended] Timeout after 30 minutes.`
                         : 'Monitor ended after 30 minutes. No text was retrieved.';
                     liveResponseUpdateVersion += 1;
-                    const timeoutTitle = `${PHASE_ICONS.timeout} Timeout`;
-                    const timeoutFooter = `⏱️ Elapsed: ${elapsed}s | Timeout`;
-                    await sendChunkedResponse(timeoutTitle, timeoutFooter, payload, timeoutIsHtml);
+                    await sendChunkedResponse(`${PHASE_ICONS.timeout} Timeout`, `⏱️ ${elapsed}s`, payload, timeoutIsHtml);
                     liveActivityUpdateVersion += 1;
-                    await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, sanitizedTimeoutLogs || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                    thinkingActive = false;
+                    await setProgressMessage(`<b>${PHASE_ICONS.timeout} ${(0, telegramFormatter_1.escapeHtml)(modelLabel)} · ${elapsed}s</b>\n\n${buildProgressBody()}`, { expectedVersion: liveActivityUpdateVersion });
                 }
                 catch (error) {
                     logger_1.logger.error(`[sendPrompt:${monitorTraceId}] onTimeout failed:`, error);
@@ -511,10 +714,7 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
                 clearInterval(elapsedTimer);
                 return;
             }
-            const elapsed = Math.round((Date.now() - startTime) / 1000);
-            liveActivityUpdateVersion += 1;
-            const v = liveActivityUpdateVersion;
-            upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+            triggerProgressRefresh();
         }, 5000);
     }
     catch (e) {
@@ -559,6 +759,34 @@ const startBot = async (cliLogLevel) => {
     const cleanupHandler = new cleanupCommandHandler_1.CleanupCommandHandler(chatSessionRepo, workspaceBindingRepo);
     const bot = new grammy_1.Bot(config.telegramBotToken);
     bridge.botApi = bot.api;
+    // Notify user on WebSocket connection lifecycle events
+    bridge.pool.on('workspace:disconnected', (projectName) => {
+        const channel = bridge.lastActiveChannel;
+        if (!channel || !bridge.botApi)
+            return;
+        bridge.botApi.sendMessage(channel.chatId, `⚠️ <b>${(0, telegramFormatter_1.escapeHtml)(projectName)}</b>: Connection lost. Reconnecting…`, {
+            parse_mode: 'HTML',
+            message_thread_id: channel.threadId,
+        }).catch((err) => logger_1.logger.error('[Bot] Failed to send disconnect notification:', err));
+    });
+    bridge.pool.on('workspace:reconnected', (projectName) => {
+        const channel = bridge.lastActiveChannel;
+        if (!channel || !bridge.botApi)
+            return;
+        bridge.botApi.sendMessage(channel.chatId, `✅ <b>${(0, telegramFormatter_1.escapeHtml)(projectName)}</b>: Reconnected.`, {
+            parse_mode: 'HTML',
+            message_thread_id: channel.threadId,
+        }).catch((err) => logger_1.logger.error('[Bot] Failed to send reconnect notification:', err));
+    });
+    bridge.pool.on('workspace:reconnectFailed', (projectName) => {
+        const channel = bridge.lastActiveChannel;
+        if (!channel || !bridge.botApi)
+            return;
+        bridge.botApi.sendMessage(channel.chatId, `❌ <b>${(0, telegramFormatter_1.escapeHtml)(projectName)}</b>: Reconnection failed. Send a message to retry.`, {
+            parse_mode: 'HTML',
+            message_thread_id: channel.threadId,
+        }).catch((err) => logger_1.logger.error('[Bot] Failed to send reconnect-failed notification:', err));
+    });
     const topicManager = new telegramTopicManager_1.TelegramTopicManager(bot.api, 0);
     // Auth middleware
     bot.use(async (ctx, next) => {
@@ -645,11 +873,14 @@ const startBot = async (cliLogLevel) => {
     });
     // /model command
     bot.command('model', async (ctx) => {
+        const ch = getChannel(ctx);
+        const resolved = await resolveWorkspaceAndCdp(ch);
+        const getCdp = () => resolved?.cdp ?? (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
         const modelName = ctx.match?.trim();
         if (modelName) {
-            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            const cdp = getCdp();
             if (!cdp) {
-                await ctx.reply('Not connected to CDP.');
+                await ctx.reply('Not connected to CDP. Send a message first to connect.');
                 return;
             }
             const res = await cdp.setUiModel(modelName);
@@ -661,7 +892,7 @@ const startBot = async (cliLogLevel) => {
             }
         }
         else {
-            await (0, modelsUi_1.sendModelsUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, { getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge), fetchQuota: async () => bridge.quota.fetchQuota() });
+            await (0, modelsUi_1.sendModelsUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, { getCurrentCdp: getCdp, fetchQuota: async () => bridge.quota.fetchQuota() });
         }
     });
     // /template command