remoat 0.2.8 → 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");
@@ -39,6 +39,7 @@ const autoAcceptUi_1 = require("../ui/autoAcceptUi");
 const screenshotUi_1 = require("../ui/screenshotUi");
 const projectListUi_1 = require("../ui/projectListUi");
 const sessionPickerUi_1 = require("../ui/sessionPickerUi");
+const planUi_1 = require("../ui/planUi");
 const PHASE_ICONS = {
     sending: '📡',
     thinking: '🧠',
@@ -68,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
@@ -78,6 +79,10 @@ function stripHtmlForFile(html) {
     return text;
 }
 const userStopRequestedChannels = new Set();
+/** Channels where the user is expected to type plan edit instructions */
+const planEditPendingChannels = new Map();
+/** Cached plan content pages per channel */
+const planContentCache = new Map();
 function channelKey(ch) {
     return ch.threadId ? `${ch.chatId}:${ch.threadId}` : String(ch.chatId);
 }
@@ -137,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;
@@ -149,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) {
@@ -177,43 +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 = '';
     const LIVE_RESPONSE_MAX_LEN = 3800;
-    const LIVE_ACTIVITY_MAX_LEN = 3800;
-    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 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)
@@ -232,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);
         }
@@ -249,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;
@@ -316,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,
@@ -326,12 +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;
+                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();
+                }
+                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)
@@ -342,6 +479,8 @@ async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService
                     lastProgressText = separated.output;
             },
             onComplete: async (finalText, meta) => {
+                if (isFinalized)
+                    return; // Guard: prevent duplicate completion
                 isFinalized = true;
                 if (elapsedTimer) {
                     clearInterval(elapsedTimer);
@@ -357,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) {
@@ -373,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 {
@@ -450,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);
@@ -472,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) {
@@ -520,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) => {
@@ -606,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);
@@ -622,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
@@ -1051,7 +1321,7 @@ const startBot = async (cliLogLevel) => {
             }
             return;
         }
-        // Planning buttons
+        // Planning buttons (legacy parsing for backward compat)
         const planningAction = (0, cdpBridgeManager_1.parsePlanningCustomId)(data);
         if (planningAction) {
             const projectName = planningAction.projectName ?? bridge.lastActiveWorkspace;
@@ -1072,8 +1342,12 @@ const startBot = async (cliLogLevel) => {
                         await new Promise(r => setTimeout(r, 500));
                     }
                     if (planContent) {
-                        const truncated = planContent.length > 3800 ? planContent.substring(0, 3800) + '\n\n(truncated)' : planContent;
-                        await bot.api.sendMessage(ch.chatId, `<b>Plan Content</b>\n\n${(0, telegramFormatter_1.escapeHtml)(truncated)}`, { parse_mode: 'HTML', message_thread_id: ch.threadId });
+                        const chKey = channelKey(ch);
+                        const pages = (0, planUi_1.paginatePlanContent)(planContent);
+                        planContentCache.set(chKey, pages);
+                        const targetChannelStr = ch.threadId ? String(ch.threadId) : String(ch.chatId);
+                        const { text: pageText, keyboard: pageKeyboard } = (0, planUi_1.buildPlanContentUI)(pages, 0, projectName || '', targetChannelStr);
+                        await bot.api.sendMessage(ch.chatId, pageText, { parse_mode: 'HTML', message_thread_id: ch.threadId, reply_markup: pageKeyboard });
                     }
                 }
                 await ctx.answerCallbackQuery({ text: clicked ? 'Opened' : 'Open button not found.' });
@@ -1089,6 +1363,104 @@ const startBot = async (cliLogLevel) => {
             }
             return;
         }
+        // New plan UI buttons (View/Proceed/Edit/Refresh)
+        if (data.startsWith(planUi_1.PLAN_VIEW_BTN + ':')) {
+            const suffix = data.substring(planUi_1.PLAN_VIEW_BTN.length + 1);
+            const [projectName] = suffix.split(':');
+            const detector = projectName ? bridge.pool.getPlanningDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Planning detector not found.' });
+                return;
+            }
+            const clicked = await detector.clickOpenButton();
+            if (clicked) {
+                await new Promise(r => setTimeout(r, 500));
+                let planContent = null;
+                for (let attempt = 0; attempt < 3; attempt++) {
+                    planContent = await detector.extractPlanContent();
+                    if (planContent)
+                        break;
+                    await new Promise(r => setTimeout(r, 500));
+                }
+                if (planContent) {
+                    const chKey = channelKey(ch);
+                    const pages = (0, planUi_1.paginatePlanContent)(planContent);
+                    planContentCache.set(chKey, pages);
+                    const targetChannelStr = ch.threadId ? String(ch.threadId) : String(ch.chatId);
+                    const { text: pageText, keyboard: pageKeyboard } = (0, planUi_1.buildPlanContentUI)(pages, 0, projectName, targetChannelStr);
+                    await bot.api.sendMessage(ch.chatId, pageText, { parse_mode: 'HTML', message_thread_id: ch.threadId, reply_markup: pageKeyboard });
+                }
+            }
+            await ctx.answerCallbackQuery({ text: clicked ? 'Opened' : 'Open button not found.' });
+            return;
+        }
+        if (data.startsWith(planUi_1.PLAN_PROCEED_BTN + ':')) {
+            const suffix = data.substring(planUi_1.PLAN_PROCEED_BTN.length + 1);
+            const [projectName] = suffix.split(':');
+            const detector = projectName ? bridge.pool.getPlanningDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Planning detector not found.' });
+                return;
+            }
+            const clicked = await detector.clickProceedButton();
+            if (clicked) {
+                planEditPendingChannels.delete(channelKey(ch));
+                try {
+                    await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+                }
+                catch { }
+            }
+            await ctx.answerCallbackQuery({ text: clicked ? 'Proceeding...' : 'Proceed button not found.' });
+            return;
+        }
+        if (data.startsWith(planUi_1.PLAN_EDIT_BTN + ':')) {
+            const suffix = data.substring(planUi_1.PLAN_EDIT_BTN.length + 1);
+            const [projectName] = suffix.split(':');
+            planEditPendingChannels.set(channelKey(ch), { projectName });
+            await ctx.answerCallbackQuery({ text: 'Type your edit instructions (or /cancel).' });
+            await bot.api.sendMessage(ch.chatId, '<b>Edit Plan</b>\n\nType your plan edit instructions below.\nSend <code>/cancel</code> to cancel.', { parse_mode: 'HTML', message_thread_id: ch.threadId });
+            return;
+        }
+        if (data.startsWith(planUi_1.PLAN_REFRESH_BTN + ':')) {
+            const suffix = data.substring(planUi_1.PLAN_REFRESH_BTN.length + 1);
+            const [projectName, targetChannelStr] = suffix.split(':');
+            const detector = projectName ? bridge.pool.getPlanningDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Planning detector not found.' });
+                return;
+            }
+            const info = detector.getLastDetectedInfo();
+            if (info) {
+                const { text: uiText, keyboard: uiKeyboard } = (0, planUi_1.buildPlanNotificationUI)(info, projectName, targetChannelStr || String(ch.chatId));
+                try {
+                    await ctx.editMessageText(uiText, { parse_mode: 'HTML', reply_markup: uiKeyboard });
+                }
+                catch { }
+            }
+            await ctx.answerCallbackQuery({ text: 'Refreshed' });
+            return;
+        }
+        // Plan pagination
+        if (data.startsWith(planUi_1.PLAN_PAGE_PREFIX + ':')) {
+            const rest = data.substring(planUi_1.PLAN_PAGE_PREFIX.length + 1);
+            const colonIdx = rest.indexOf(':');
+            const page = parseInt(rest.substring(0, colonIdx), 10);
+            const suffix = rest.substring(colonIdx + 1);
+            const [projectName, targetChannelStr] = suffix.split(':');
+            const chKey = channelKey(ch);
+            const pages = planContentCache.get(chKey);
+            if (!pages || isNaN(page)) {
+                await ctx.answerCallbackQuery({ text: 'Page not found.' });
+                return;
+            }
+            const { text: pageText, keyboard: pageKeyboard } = (0, planUi_1.buildPlanContentUI)(pages, page, projectName, targetChannelStr || String(ch.chatId));
+            try {
+                await ctx.editMessageText(pageText, { parse_mode: 'HTML', reply_markup: pageKeyboard });
+            }
+            catch { }
+            await ctx.answerCallbackQuery({ text: `Page ${page + 1}/${pages.length}` });
+            return;
+        }
         // Error popup buttons
         const errorAction = (0, cdpBridgeManager_1.parseErrorPopupCustomId)(data);
         if (errorAction) {
@@ -1187,6 +1559,32 @@ const startBot = async (cliLogLevel) => {
         const text = ctx.message.text.trim();
         if (!text)
             return;
+        // Plan edit interception
+        const pendingPlanEdit = planEditPendingChannels.get(key);
+        if (pendingPlanEdit) {
+            if (text === '/cancel') {
+                planEditPendingChannels.delete(key);
+                await ctx.reply('Plan edit cancelled.');
+                return;
+            }
+            planEditPendingChannels.delete(key);
+            const editPrompt = `Please revise the plan based on the following feedback:\n\n${text}`;
+            const resolved = await resolveWorkspaceAndCdp(ch);
+            const cdp = resolved?.cdp ?? (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (!cdp) {
+                await ctx.reply('Not connected to CDP.');
+                return;
+            }
+            await ctx.reply('Sending plan edit...');
+            await promptDispatcher.send({
+                channel: ch,
+                prompt: editPrompt,
+                cdp,
+                inboundImages: [],
+                options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+            });
+            return;
+        }
         // Check if it looks like a text command
         const parsed = (0, messageParser_1.parseMessageContent)(text);
         if (parsed.isCommand && parsed.commandName) {