lazy-gravity 0.0.4 → 0.2.0

package/dist/services/responseMonitor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseMonitor = exports.RESPONSE_SELECTORS = void 0;
 const logger_1 = require("../utils/logger");
+const assistantDomExtractor_1 = require("./assistantDomExtractor");
 /** Lean DOM selectors for response extraction */
 exports.RESPONSE_SELECTORS = {
     /** Scored selector approach for extracting response text.
@@ -27,7 +28,7 @@ exports.RESPONSE_SELECTORS = {
         const looksLikeActivityLog = (text) => {
             const normalized = (text || '').trim().toLowerCase();
             if (!normalized) return false;
-            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|fetching|connecting|creating|updating|deleting|installing|building|compiling|deploying|checking|scanning|parsing|resolving|downloading|uploading|analyzed|read|wrote|ran|created|updated|deleted|fetched|built|compiled|installed|resolved|downloaded|connected)\\b/i;
             if (activityPattern.test(normalized) && normalized.length <= 220) return true;
             if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
             if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
@@ -43,6 +44,8 @@ exports.RESPONSE_SELECTORS = {
         const isInsideExcludedContainer = (node) => {
             if (node.closest('details')) return true;
             if (node.closest('[class*="feedback"], footer')) return true;
+            if (node.closest('.notify-user-container')) return true;
+            if (node.closest('[role="dialog"]')) return true;
             return false;
         };
 
@@ -57,6 +60,15 @@ exports.RESPONSE_SELECTORS = {
             return false;
         };
 
+        const looksLikeQuotaPopup = (text) => {
+            var lower = (text || '').trim().toLowerCase();
+            // Inline error: "Error You have exhausted your quota on this model."
+            if (lower.includes('exhausted your quota') || lower.includes('exhausted quota')) return true;
+            // Popup: quota keyword + dismiss/upgrade button text
+            if (!lower.includes('model quota reached') && !lower.includes('quota exceeded') && !lower.includes('rate limit')) return false;
+            return lower.includes('dismiss') || lower.includes('upgrade');
+        };
+
         const combinedSelector = selectors.map((s) => s.sel).join(', ');
         const seen = new Set();
 
@@ -72,6 +84,7 @@ exports.RESPONSE_SELECTORS = {
                 if (looksLikeActivityLog(text)) continue;
                 if (looksLikeFeedbackFooter(text)) continue;
                 if (looksLikeToolOutput(text)) continue;
+                if (looksLikeQuotaPopup(text)) continue;
                 // Prefer recency first: return the newest acceptable node.
                 return text;
             }
@@ -185,7 +198,7 @@ exports.RESPONSE_SELECTORS = {
         const looksLikeActivityLog = (text) => {
             const normalized = (text || '').trim().toLowerCase();
             if (!normalized) return false;
-            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|fetching|connecting|creating|updating|deleting|installing|building|compiling|deploying|checking|scanning|parsing|resolving|downloading|uploading|analyzed|read|wrote|ran|created|updated|deleted|fetched|built|compiled|installed|resolved|downloaded|connected)\\b/i;
             if (activityPattern.test(normalized) && normalized.length <= 220) return true;
             if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
             if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
@@ -199,6 +212,8 @@ exports.RESPONSE_SELECTORS = {
         const isInsideExcludedContainer = (node) => {
             if (node.closest('details')) return true;
             if (node.closest('[class*="feedback"], footer')) return true;
+            if (node.closest('.notify-user-container')) return true;
+            if (node.closest('[role="dialog"]')) return true;
             return false;
         };
         const looksLikeToolOutput = (text) => {
@@ -229,6 +244,12 @@ exports.RESPONSE_SELECTORS = {
                     else if (looksLikeActivityLog(text)) skip = 'activity-log';
                     else if (looksLikeFeedbackFooter(text)) skip = 'feedback-footer';
                     else if (looksLikeToolOutput(text)) skip = 'tool-output';
+                    else {
+                        var qlower = (text || '').trim().toLowerCase();
+                        if (qlower.includes('exhausted your quota') || qlower.includes('exhausted quota')) skip = 'quota-popup';
+                        else if ((qlower.includes('model quota reached') || qlower.includes('quota exceeded') || qlower.includes('rate limit'))
+                            && (qlower.includes('dismiss') || qlower.includes('upgrade'))) skip = 'quota-popup';
+                    }
                     const classes = (node.className || '').toString().slice(0, 80);
                     results.push({
                         sel,
@@ -263,7 +284,7 @@ exports.RESPONSE_SELECTORS = {
         const looksLikeActivityLog = (text) => {
             const normalized = (text || '').trim().toLowerCase();
             if (!normalized) return false;
-            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|fetching|connecting|creating|updating|deleting|installing|building|compiling|deploying|checking|scanning|parsing|resolving|downloading|uploading|analyzed|read|wrote|ran|created|updated|deleted|fetched|built|compiled|installed|resolved|downloaded|connected)\\b/i;
             if (activityPattern.test(normalized) && normalized.length <= 220) return true;
             if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
             if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
@@ -284,6 +305,8 @@ exports.RESPONSE_SELECTORS = {
         const isInsideExcludedContainer = (node) => {
             if (node.closest('details')) return true;
             if (node.closest('[class*="feedback"], footer')) return true;
+            if (node.closest('.notify-user-container')) return true;
+            if (node.closest('[role="dialog"]')) return true;
             return false;
         };
 
@@ -309,11 +332,32 @@ exports.RESPONSE_SELECTORS = {
 
         return results;
     })()`,
-    /** Quota error detection */
+    /** Quota error detection — text-based h3 span match first, class-based fallback second */
     QUOTA_ERROR: `(() => {
         const panel = document.querySelector('.antigravity-agent-side-panel');
         const scope = panel || document;
+        const QUOTA_KEYWORDS = ['model quota reached', 'rate limit', 'quota exceeded', 'exhausted your quota', 'exhausted quota'];
+        const isInsideResponse = (node) =>
+            node.closest('.rendered-markdown, .prose, pre, code, [data-message-author-role="assistant"], [data-message-role="assistant"], [class*="message-content"]');
 
+        // Primary: text-based detection via h3 span (Tailwind-only popup)
+        const headings = scope.querySelectorAll('h3 span, h3');
+        for (const el of headings) {
+            if (isInsideResponse(el)) continue;
+            const text = (el.textContent || '').trim().toLowerCase();
+            if (QUOTA_KEYWORDS.some(kw => text.includes(kw))) return true;
+        }
+
+        // Inline error: "Error You have exhausted your quota on this model."
+        // Appears in process log area as a span inside flex containers
+        const inlineSpans = scope.querySelectorAll('span');
+        for (const el of inlineSpans) {
+            if (isInsideResponse(el)) continue;
+            const text = (el.textContent || '').trim().toLowerCase();
+            if (text.includes('exhausted your quota') || text.includes('exhausted quota')) return true;
+        }
+
+        // Fallback: semantic class-based detection
         const errorSelectors = [
             '[role="alert"]',
             '[class*="error"]',
@@ -327,16 +371,67 @@ exports.RESPONSE_SELECTORS = {
         ];
         const errorElements = scope.querySelectorAll(errorSelectors.join(', '));
         for (const el of errorElements) {
-            if (el.closest('.rendered-markdown, .prose, pre, code, [data-message-author-role="assistant"], [data-message-role="assistant"], [class*="message-content"]')) {
-                continue;
-            }
+            if (isInsideResponse(el)) continue;
             const text = (el.textContent || '').trim().toLowerCase();
-            if (text.includes('model quota reached') || text.includes('rate limit') || text.includes('quota exceeded')) {
-                return true;
-            }
+            if (QUOTA_KEYWORDS.some(kw => text.includes(kw))) return true;
         }
         return false;
     })()`,
+    /** Structured DOM extraction — walks DOM to produce typed segment array */
+    RESPONSE_STRUCTURED: (0, assistantDomExtractor_1.extractAssistantSegmentsPayloadScript)(),
+    /** One-shot DOM diagnostic — dumps DOM structure around activity areas */
+    DOM_DIAGNOSTIC: `(() => {
+        var panel = document.querySelector('.antigravity-agent-side-panel');
+        var scope = panel || document;
+        var diag = { detailsCount: 0, detailsDump: [], activityNodes: [], allTextNodes: [] };
+
+        // 1. Dump all <details> elements
+        var details = scope.querySelectorAll('details');
+        diag.detailsCount = details.length;
+        for (var i = 0; i < Math.min(details.length, 5); i++) {
+            diag.detailsDump.push({
+                outerHTML: details[i].outerHTML.slice(0, 500),
+                summaryText: (details[i].querySelector('summary') || {}).textContent || '(no summary)',
+                childCount: details[i].children.length
+            });
+        }
+
+        // 2. Find all text nodes that look like activity
+        var selectors = '.rendered-markdown, .leading-relaxed.select-text, .flex.flex-col.gap-y-3, [data-message-author-role="assistant"], [data-message-role="assistant"], [class*="assistant-message"], [class*="message-content"], [class*="markdown-body"], .prose';
+        var nodes = scope.querySelectorAll(selectors);
+        for (var j = 0; j < nodes.length; j++) {
+            var text = (nodes[j].innerText || nodes[j].textContent || '').trim();
+            if (!text || text.length < 2) continue;
+            diag.allTextNodes.push({
+                tag: nodes[j].tagName,
+                className: (nodes[j].className || '').toString().slice(0, 100),
+                text: text.slice(0, 200),
+                insideDetails: !!nodes[j].closest('details'),
+                length: text.length
+            });
+        }
+
+        // 3. Broader scan: any element with activity-like text
+        var allEls = scope.querySelectorAll('*');
+        for (var k = 0; k < allEls.length; k++) {
+            var el = allEls[k];
+            if (el.children.length > 2) continue; // only leaf-ish nodes
+            var t = (el.textContent || '').trim();
+            if (!t || t.length < 5 || t.length > 300) continue;
+            var lower = t.toLowerCase();
+            if (/^(?:analy[sz]|read|writ|run|search|think|process|execut|debug|test)/i.test(lower) || /\\//.test(t)) {
+                diag.activityNodes.push({
+                    tag: el.tagName,
+                    className: (el.className || '').toString().slice(0, 100),
+                    text: t.slice(0, 200),
+                    parentTag: el.parentElement ? el.parentElement.tagName : null,
+                    parentClass: el.parentElement ? (el.parentElement.className || '').toString().slice(0, 100) : null,
+                    insideDetails: !!el.closest('details')
+                });
+            }
+        }
+        return diag;
+    })()`,
 };
 /**
  * Lean AI response monitor.
@@ -351,13 +446,13 @@ class ResponseMonitor {
     pollIntervalMs;
     maxDurationMs;
     stopGoneConfirmCount;
+    extractionMode;
     onProgress;
     onComplete;
     onTimeout;
     onPhaseChange;
     onProcessLog;
     pollTimer = null;
-    timeoutTimer = null;
     isRunning = false;
     lastText = null;
     baselineText = null;
@@ -366,11 +461,21 @@ class ResponseMonitor {
     stopGoneCount = 0;
     quotaDetected = false;
     seenProcessLogKeys = new Set();
+    structuredDiagLogged = false;
+    // CDP disconnect handling (#48)
+    isPaused = false;
+    onCdpDisconnected = null;
+    onCdpReconnected = null;
+    onCdpReconnectFailed = null;
+    // Activity-based timeout (#49)
+    lastActivityTime = 0;
     constructor(options) {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
         this.maxDurationMs = options.maxDurationMs ?? 300000;
         this.stopGoneConfirmCount = options.stopGoneConfirmCount ?? 3;
+        this.extractionMode = options.extractionMode
+            ?? (process.env.EXTRACTION_MODE === 'legacy' ? 'legacy' : 'structured');
         this.onProgress = options.onProgress;
         this.onComplete = options.onComplete;
         this.onTimeout = options.onTimeout;
@@ -379,18 +484,31 @@ class ResponseMonitor {
     }
     /** Start monitoring */
     async start() {
+        return this.initMonitoring(false);
+    }
+    /**
+     * Start monitoring in passive mode.
+     * Same as start() but with generationStarted=true, so text changes
+     * are detected immediately without waiting for the stop button to appear.
+     * Used when joining an existing session that may already be generating.
+     */
+    async startPassive() {
+        return this.initMonitoring(true);
+    }
+    /** Internal initialization shared between start() and startPassive() */
+    async initMonitoring(passive) {
         if (this.isRunning)
             return;
         this.isRunning = true;
+        this.isPaused = false;
         this.lastText = null;
         this.baselineText = null;
-        this.generationStarted = false;
-        this.currentPhase = 'waiting';
+        this.generationStarted = passive;
+        this.currentPhase = passive ? 'generating' : 'waiting';
         this.stopGoneCount = 0;
         this.quotaDetected = false;
         this.seenProcessLogKeys = new Set();
-        // Always fire callback on start, even though phase is already 'waiting'
-        this.onPhaseChange?.('waiting', null);
+        this.onPhaseChange?.(this.currentPhase, null);
         // Capture baseline text
         try {
             const baseResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
@@ -414,35 +532,44 @@ class ResponseMonitor {
         catch {
             // baseline capture only
         }
-        // Set timeout timer
-        if (this.maxDurationMs > 0) {
-            this.timeoutTimer = setTimeout(async () => {
-                const lastText = this.lastText ?? '';
-                this.setPhase('timeout', lastText);
-                await this.stop();
-                try {
-                    await Promise.resolve(this.onTimeout?.(lastText));
-                }
-                catch (error) {
-                    logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+        // In structured mode, also capture activity lines from the structured
+        // extraction to align the baseline with polling logic. The PROCESS_LOGS
+        // script skips <details> content, but structured extraction (Pass 2)
+        // explicitly walks <details> elements — without this, tool-call/thinking
+        // entries from previous turns leak into the process log as "new" entries.
+        if (this.extractionMode === 'structured') {
+            try {
+                const structuredBaseline = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED));
+                const baselineClassified = (0, assistantDomExtractor_1.classifyAssistantSegments)(structuredBaseline?.result?.value);
+                if (baselineClassified.diagnostics.source === 'dom-structured') {
+                    for (const line of baselineClassified.activityLines) {
+                        const key = (line || '').replace(/\r/g, '').trim().slice(0, 200);
+                        if (key)
+                            this.seenProcessLogKeys.add(key);
+                    }
                 }
-            }, this.maxDurationMs);
+            }
+            catch {
+                // structured baseline is best-effort
+            }
         }
-        logger_1.logger.info(`── Monitoring started | poll=${this.pollIntervalMs}ms timeout=${this.maxDurationMs / 1000}s baseline=${this.baselineText?.length ?? 0}ch`);
-        // Start polling
+        // Activity-based timeout: track last activity time instead of fixed timer (#49)
+        this.lastActivityTime = Date.now();
+        // Register CDP connection event listeners (#48)
+        this.registerCdpConnectionListeners();
+        const mode = passive ? 'Passive monitoring' : 'Monitoring';
+        logger_1.logger.debug(`── ${mode} started | poll=${this.pollIntervalMs}ms inactivityTimeout=${this.maxDurationMs / 1000}s baseline=${this.baselineText?.length ?? 0}ch`);
         this.schedulePoll();
     }
     /** Stop monitoring */
     async stop() {
         this.isRunning = false;
+        this.isPaused = false;
+        this.unregisterCdpConnectionListeners();
         if (this.pollTimer) {
             clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-            this.timeoutTimer = null;
-        }
     }
     /** Get current phase */
     getPhase() {
@@ -494,14 +621,71 @@ class ResponseMonitor {
                 case 'quotaReached':
                     logger_1.logger.warn('Quota Reached');
                     break;
+                case 'disconnected':
+                    logger_1.logger.warn(`CDP Disconnected — paused (${len} chars captured)`);
+                    break;
                 default:
                     logger_1.logger.phase(`${phase}`);
             }
             this.onPhaseChange?.(phase, text);
         }
     }
+    registerCdpConnectionListeners() {
+        this.onCdpDisconnected = () => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.warn('[ResponseMonitor] CDP disconnected — pausing poll');
+            this.isPaused = true;
+            if (this.pollTimer) {
+                clearTimeout(this.pollTimer);
+                this.pollTimer = null;
+            }
+            this.setPhase('disconnected', this.lastText);
+        };
+        this.onCdpReconnected = () => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.warn('[ResponseMonitor] CDP reconnected — resuming poll');
+            this.isPaused = false;
+            this.lastActivityTime = Date.now();
+            const resumePhase = this.generationStarted ? 'generating' : 'waiting';
+            this.setPhase(resumePhase, this.lastText);
+            this.schedulePoll();
+        };
+        this.onCdpReconnectFailed = async (err) => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.error('[ResponseMonitor] CDP reconnection failed — stopping monitor:', err.message);
+            const lastText = this.lastText ?? '';
+            this.setPhase('disconnected', lastText);
+            await this.stop();
+            try {
+                await Promise.resolve(this.onTimeout?.(lastText));
+            }
+            catch (error) {
+                logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+            }
+        };
+        this.cdpService.on('disconnected', this.onCdpDisconnected);
+        this.cdpService.on('reconnected', this.onCdpReconnected);
+        this.cdpService.on('reconnectFailed', this.onCdpReconnectFailed);
+    }
+    unregisterCdpConnectionListeners() {
+        if (this.onCdpDisconnected) {
+            this.cdpService.removeListener('disconnected', this.onCdpDisconnected);
+            this.onCdpDisconnected = null;
+        }
+        if (this.onCdpReconnected) {
+            this.cdpService.removeListener('reconnected', this.onCdpReconnected);
+            this.onCdpReconnected = null;
+        }
+        if (this.onCdpReconnectFailed) {
+            this.cdpService.removeListener('reconnectFailed', this.onCdpReconnectFailed);
+            this.onCdpReconnectFailed = null;
+        }
+    }
     schedulePoll() {
-        if (!this.isRunning)
+        if (!this.isRunning || this.isPaused)
             return;
         this.pollTimer = setTimeout(async () => {
             await this.poll();
@@ -523,11 +707,34 @@ class ResponseMonitor {
         return params;
     }
     /**
-     * Single poll: exactly 4 CDP calls.
-     * 1. Stop button check
-     * 2. Quota error check
-     * 3. Text extraction
-     * 4. Process log extraction
+     * Emit new process log entries, deduplicating against previously seen keys.
+     */
+    emitNewProcessLogs(entries) {
+        const newEntries = [];
+        for (const line of entries) {
+            const normalized = (line || '').replace(/\r/g, '').trim();
+            if (!normalized)
+                continue;
+            const key = normalized.slice(0, 200);
+            if (this.seenProcessLogKeys.has(key))
+                continue;
+            this.seenProcessLogKeys.add(key);
+            newEntries.push(normalized.slice(0, 300));
+        }
+        if (newEntries.length > 0) {
+            this.lastActivityTime = Date.now();
+            try {
+                this.onProcessLog?.(newEntries.join('\n\n'));
+            }
+            catch {
+                // callback error
+            }
+        }
+    }
+    /**
+     * Single poll cycle.
+     * - Legacy mode: 4 CDP calls (stop, quota, text, process logs).
+     * - Structured mode: 3-4 CDP calls (stop, quota, structured; legacy text on fallback).
      */
     async poll() {
         try {
@@ -538,45 +745,62 @@ class ResponseMonitor {
             // 2. Quota error check
             const quotaResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.QUOTA_ERROR));
             const quotaDetected = quotaResult?.result?.value === true;
-            // 3. Text extraction
-            const textResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
-            const rawText = textResult?.result?.value;
-            const exceptionDetail = textResult?.result?.exceptionDetails ?? textResult?.exceptionDetails;
-            if (exceptionDetail) {
-                logger_1.logger.warn('[ResponseMonitor:poll] RESPONSE_TEXT threw:', exceptionDetail.text ?? JSON.stringify(exceptionDetail).slice(0, 200));
-            }
-            const currentText = typeof rawText === 'string' ? rawText.trim() || null : null;
-            // 4. Process log extraction
-            try {
-                const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
-                const logEntries = logResult?.result?.value;
-                if (Array.isArray(logEntries)) {
-                    const newEntries = [];
-                    for (const raw of logEntries) {
-                        const normalized = (raw || '').replace(/\r/g, '').trim();
-                        if (!normalized)
-                            continue;
-                        const key = normalized.slice(0, 200);
-                        if (this.seenProcessLogKeys.has(key))
-                            continue;
-                        this.seenProcessLogKeys.add(key);
-                        newEntries.push(normalized.slice(0, 300));
-                    }
-                    if (newEntries.length > 0) {
-                        try {
-                            this.onProcessLog?.(newEntries.join('\n\n'));
+            // 3. Text extraction (structured or legacy)
+            let currentText = null;
+            let structuredHandledLogs = false;
+            if (this.extractionMode === 'structured') {
+                // Structured: use DOM segment extraction with HTML-to-Markdown
+                try {
+                    const structuredResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED));
+                    const payload = structuredResult?.result?.value;
+                    const classified = (0, assistantDomExtractor_1.classifyAssistantSegments)(payload);
+                    if (classified.diagnostics.source === 'dom-structured') {
+                        currentText = classified.finalOutputText.trim() || null;
+                        structuredHandledLogs = true;
+                        if (!this.structuredDiagLogged) {
+                            this.structuredDiagLogged = true;
+                            logger_1.logger.debug('[ResponseMonitor] Structured extraction OK — segments:', classified.diagnostics.segmentCounts);
                         }
-                        catch {
-                            // callback error
+                        // Emit structured activity lines as process logs
+                        if (classified.activityLines.length > 0) {
+                            this.emitNewProcessLogs(classified.activityLines);
                         }
                     }
+                    else if (!this.structuredDiagLogged) {
+                        this.structuredDiagLogged = true;
+                        logger_1.logger.warn('[ResponseMonitor:poll] Structured extraction failed — reason:', classified.diagnostics.fallbackReason ?? 'unknown', '| payload type:', typeof payload, '| payload:', payload === null ? 'null' : payload === undefined ? 'undefined' : 'object');
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn('[ResponseMonitor:poll] RESPONSE_STRUCTURED failed, falling back to legacy:', error);
                 }
             }
-            catch {
-                // process log extraction is best-effort
+            // Legacy path (or fallback from structured)
+            if (currentText === null) {
+                const textResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
+                const rawText = textResult?.result?.value;
+                const exceptionDetail = textResult?.result?.exceptionDetails ?? textResult?.exceptionDetails;
+                if (exceptionDetail) {
+                    logger_1.logger.warn('[ResponseMonitor:poll] RESPONSE_TEXT threw:', exceptionDetail.text ?? JSON.stringify(exceptionDetail).slice(0, 200));
+                }
+                currentText = typeof rawText === 'string' ? rawText.trim() || null : null;
+            }
+            // 4. Process log extraction — always when structured didn't handle it
+            if (!structuredHandledLogs) {
+                try {
+                    const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
+                    const logEntries = logResult?.result?.value;
+                    if (Array.isArray(logEntries)) {
+                        this.emitNewProcessLogs(logEntries);
+                    }
+                }
+                catch {
+                    // process log extraction is best-effort
+                }
             }
             // Handle stop button appearing
             if (isGenerating) {
+                this.lastActivityTime = Date.now();
                 if (!this.generationStarted) {
                     this.generationStarted = true;
                     this.setPhase('thinking', null);
@@ -611,6 +835,7 @@ class ResponseMonitor {
             // Text change handling
             const textChanged = effectiveText !== null && effectiveText !== this.lastText;
             if (textChanged) {
+                this.lastActivityTime = Date.now();
                 this.lastText = effectiveText;
                 if (this.currentPhase === 'waiting' || this.currentPhase === 'thinking') {
                     this.setPhase('generating', effectiveText);
@@ -636,6 +861,19 @@ class ResponseMonitor {
                     return;
                 }
             }
+            // Activity-based inactivity timeout (#49)
+            if (this.maxDurationMs > 0 && Date.now() - this.lastActivityTime >= this.maxDurationMs) {
+                const lastText = this.lastText ?? '';
+                this.setPhase('timeout', lastText);
+                await this.stop();
+                try {
+                    await Promise.resolve(this.onTimeout?.(lastText));
+                }
+                catch (error) {
+                    logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+                }
+                return;
+            }
         }
         catch (error) {
             logger_1.logger.error('[ResponseMonitor] poll error:', error);

package/dist/services/retryStore.js

@@ -0,0 +1,46 @@
+"use strict";
+// =============================================================================
+// Retry store — keeps retry info for the Retry button on errors
+// Extracted to avoid circular dependency between bot/index.ts and
+// interactionCreateHandler.ts.
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETRY_BTN_PREFIX = void 0;
+exports.storeRetry = storeRetry;
+exports.getRetryInfo = getRetryInfo;
+exports.deleteRetryInfo = deleteRetryInfo;
+exports.RETRY_BTN_PREFIX = 'retry_prompt_';
+const MAX_RETRY_STORE_SIZE = 100;
+/** TTL for retry entries — matches Discord interaction token lifetime (15 min) */
+const RETRY_TTL_MS = 15 * 60 * 1000;
+const retryStore = new Map();
+/** Prune entries older than RETRY_TTL_MS */
+function pruneExpired() {
+    const now = Date.now();
+    for (const [k, v] of retryStore) {
+        if (now - v.createdAt > RETRY_TTL_MS)
+            retryStore.delete(k);
+    }
+}
+function storeRetry(key, info) {
+    pruneExpired();
+    if (retryStore.size >= MAX_RETRY_STORE_SIZE) {
+        const firstKey = retryStore.keys().next().value;
+        if (firstKey !== undefined)
+            retryStore.delete(firstKey);
+    }
+    retryStore.set(key, { ...info, createdAt: Date.now() });
+}
+function getRetryInfo(key) {
+    const entry = retryStore.get(key);
+    if (!entry)
+        return undefined;
+    if (Date.now() - entry.createdAt > RETRY_TTL_MS) {
+        retryStore.delete(key);
+        return undefined;
+    }
+    return entry;
+}
+function deleteRetryInfo(key) {
+    retryStore.delete(key);
+}