lazy-gravity 0.6.1 → 0.6.2

package/dist/bot/index.js

@@ -184,13 +184,19 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
     const enqueueGeneral = createSerialTaskQueueForTest('general', monitorTraceId);
     const enqueueResponse = createSerialTaskQueueForTest('response', monitorTraceId);
     const enqueueActivity = createSerialTaskQueueForTest('activity', monitorTraceId);
+    const logDeliveryError = (scope, error) => {
+        const messageText = error instanceof Error ? error.message : String(error);
+        logger_1.logger.warn(`[DiscordDelivery:${monitorTraceId}] ${scope} failed: ${messageText}`);
+    };
     const sendEmbed = (title, description, color, fields, footerText) => enqueueGeneral(async () => {
         if (!channel)
             return;
         if (outputFormat === 'plain') {
             const chunks = (0, plainTextFormatter_1.formatAsPlainText)({ title, description, fields, footerText });
             for (const chunk of chunks) {
-                await channel.send({ content: chunk }).catch(() => { });
+                await channel.send({ content: chunk }).catch((error) => {
+                    logDeliveryError('sendEmbed/plain/send', error);
+                });
             }
             return;
         }
@@ -205,7 +211,9 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
         if (footerText) {
             embed.setFooter({ text: footerText });
         }
-        await channel.send({ embeds: [embed] }).catch(() => { });
+        await channel.send({ embeds: [embed] }).catch((error) => {
+            logDeliveryError('sendEmbed/embed/send', error);
+        });
     }, 'send-embed');
     const shouldTryGeneratedImages = (inputPrompt, responseText) => {
         const prompt = (inputPrompt || '').toLowerCase();
@@ -238,7 +246,9 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             await channel.send({
                 content: (0, i18n_1.t)(`🖼️ Detected generated images (${files.length})`),
                 files,
-            }).catch(() => { });
+            }).catch((error) => {
+                logDeliveryError('sendGeneratedImages/send', error);
+            });
         }, 'send-generated-images');
     };
     const tryEmergencyExtractText = async () => {
@@ -322,7 +332,9 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
     // Apply default model preference on CDP connect
     const defaultModelResult = await (0, defaultModelApplicator_1.applyDefaultModel)(cdp, modelService);
     if (defaultModelResult.stale && defaultModelResult.staleMessage && channel) {
-        await channel.send(defaultModelResult.staleMessage).catch(() => { });
+        await channel.send(defaultModelResult.staleMessage).catch((error) => {
+            logDeliveryError('defaultModelResult/send', error);
+        });
     }
     const localMode = modeService.getCurrentMode();
     const modeName = modeService_1.MODE_UI_NAMES[localMode] || localMode;
@@ -383,11 +395,18 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             lastLiveResponseKey = renderKey;
             for (let i = 0; i < plainChunks.length; i++) {
                 if (!liveResponseMessages[i]) {
-                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch(() => null);
+                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch((error) => {
+                        logDeliveryError('liveResponse/plain/send', error);
+                        return null;
+                    });
                     continue;
                 }
-                await liveResponseMessages[i].edit({ content: plainChunks[i] }).catch(async () => {
-                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch(() => null);
+                await liveResponseMessages[i].edit({ content: plainChunks[i] }).catch(async (error) => {
+                    logDeliveryError('liveResponse/plain/edit', error);
+                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch((sendError) => {
+                        logDeliveryError('liveResponse/plain/resend', sendError);
+                        return null;
+                    });
                 });
             }
             while (liveResponseMessages.length > plainChunks.length) {
@@ -412,11 +431,18 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 .setFooter({ text: footerText })
                 .setTimestamp();
             if (!liveResponseMessages[i]) {
-                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch((error) => {
+                    logDeliveryError('liveResponse/embed/send', error);
+                    return null;
+                });
                 continue;
             }
-            await liveResponseMessages[i].edit({ embeds: [embed] }).catch(async () => {
-                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+            await liveResponseMessages[i].edit({ embeds: [embed] }).catch(async (error) => {
+                logDeliveryError('liveResponse/embed/edit', error);
+                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch((sendError) => {
+                    logDeliveryError('liveResponse/embed/resend', sendError);
+                    return null;
+                });
             });
         }
         // Delete excess messages if page count decreased
@@ -444,11 +470,18 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             lastLiveActivityKey = renderKey;
             for (let i = 0; i < plainChunks.length; i++) {
                 if (!liveActivityMessages[i]) {
-                    liveActivityMessages[i] = await channel.send({ content: plainChunks[i] }).catch(() => null);
+                    liveActivityMessages[i] = await channel.send({ content: plainChunks[i] }).catch((error) => {
+                        logDeliveryError('liveActivity/plain/send', error);
+                        return null;
+                    });
                     continue;
                 }
-                await liveActivityMessages[i].edit({ content: plainChunks[i] }).catch(async () => {
-                    liveActivityMessages[i] = await channel.send({ content: plainChunks[i] }).catch(() => null);
+                await liveActivityMessages[i].edit({ content: plainChunks[i] }).catch(async (error) => {
+                    logDeliveryError('liveActivity/plain/edit', error);
+                    liveActivityMessages[i] = await channel.send({ content: plainChunks[i] }).catch((sendError) => {
+                        logDeliveryError('liveActivity/plain/resend', sendError);
+                        return null;
+                    });
                 });
             }
             while (liveActivityMessages.length > plainChunks.length) {
@@ -473,11 +506,18 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 .setFooter({ text: footerText })
                 .setTimestamp();
             if (!liveActivityMessages[i]) {
-                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch((error) => {
+                    logDeliveryError('liveActivity/embed/send', error);
+                    return null;
+                });
                 continue;
             }
-            await liveActivityMessages[i].edit({ embeds: [embed] }).catch(async () => {
-                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+            await liveActivityMessages[i].edit({ embeds: [embed] }).catch(async (error) => {
+                logDeliveryError('liveActivity/embed/edit', error);
+                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch((sendError) => {
+                    logDeliveryError('liveActivity/embed/resend', sendError);
+                    return null;
+                });
             });
         }
         while (liveActivityMessages.length > descriptions.length) {
@@ -488,6 +528,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
         }
     }, `upsert-activity:${opts?.source ?? 'unknown'}`);
     try {
+        const baseline = await (0, responseMonitor_1.captureResponseMonitorBaseline)(cdp);
         logger_1.logger.prompt(prompt);
         let injectResult;
         if (inboundImages.length > 0) {
@@ -516,6 +557,8 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             maxDurationMs: options?.responseTimeoutMs,
             stopGoneConfirmCount: 3,
             extractionMode: options?.extractionMode,
+            initialBaselineText: baseline.text,
+            initialSeenProcessLogKeys: baseline.processLogKeys,
             onPhaseChange: (_phase, _text) => {
                 // Phase transitions are already logged inside ResponseMonitor.setPhase()
             },
@@ -578,7 +621,9 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                             try {
                                 const modelsPayload = await (0, modelsUi_1.buildModelsUI)(cdp, () => bridge.quota.fetchQuota());
                                 if (modelsPayload && channel) {
-                                    await channel.send({ ...modelsPayload });
+                                    await channel.send({ ...modelsPayload }).catch((error) => {
+                                        logDeliveryError('quota/modelsPayload/send', error);
+                                    });
                                 }
                             }
                             catch (e) {

package/dist/bot/telegramMessageHandler.js

@@ -155,6 +155,7 @@ function createTelegramMessageHandler(deps) {
             }
             // Determine the prompt text — use default for image-only messages
             const effectivePrompt = promptText || 'Please review the attached images and respond accordingly.';
+            const baseline = await (0, responseMonitor_1.captureResponseMonitorBaseline)(cdp);
             // Inject prompt (with or without images) into Antigravity
             logger_1.logger.prompt(effectivePrompt);
             let injectResult;
@@ -208,6 +209,8 @@ function createTelegramMessageHandler(deps) {
                     maxDurationMs: TIMEOUT_MS,
                     stopGoneConfirmCount: 3,
                     extractionMode: deps.extractionMode,
+                    initialBaselineText: baseline.text,
+                    initialSeenProcessLogKeys: baseline.processLogKeys,
                     onProcessLog: (logText) => {
                         if (logText && logText.trim().length > 0) {
                             lastActivityLogText = processLogBuffer.append(logText);

package/dist/services/responseMonitor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseMonitor = exports.RESPONSE_SELECTORS = void 0;
+exports.captureResponseMonitorBaseline = captureResponseMonitorBaseline;
 const logger_1 = require("../utils/logger");
 const assistantDomExtractor_1 = require("./assistantDomExtractor");
 /** Lean DOM selectors for response extraction */
@@ -433,6 +434,125 @@ exports.RESPONSE_SELECTORS = {
         return diag;
     })()`,
 };
+/**
+ * Prefer the active runtime context first, then fall back to any discovered contexts.
+ */
+function getOrderedContextTargets(cdpService) {
+    const primaryId = cdpService.getPrimaryContextId?.() ?? null;
+    const rawContexts = cdpService.getContexts?.() ?? [];
+    const contexts = rawContexts
+        .filter((ctx) => ctx && typeof ctx.id === 'number')
+        .map((ctx) => ({
+        id: ctx.id,
+        name: typeof ctx.name === 'string' ? ctx.name : undefined,
+        url: typeof ctx.url === 'string' ? ctx.url : undefined,
+    }));
+    if (contexts.length === 0) {
+        return primaryId !== null ? [{ id: primaryId }] : [];
+    }
+    if (primaryId === null) {
+        return contexts;
+    }
+    const primary = contexts.find((ctx) => ctx.id === primaryId);
+    const ordered = primary ? [primary] : [{ id: primaryId }];
+    for (const ctx of contexts) {
+        if (ctx.id !== primaryId)
+            ordered.push(ctx);
+    }
+    return ordered;
+}
+/**
+ * Evaluate an expression across known runtime contexts until one returns an acceptable value.
+ */
+async function evaluateAcrossContexts(cdpService, expression, accept, options) {
+    const awaitPromise = options?.awaitPromise ?? true;
+    const targets = getOrderedContextTargets(cdpService);
+    let firstValue = null;
+    let lastError = null;
+    if (targets.length === 0) {
+        const result = await cdpService.call('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise,
+        });
+        return {
+            value: (result?.result?.value ?? null),
+            contextId: null,
+            contextName: null,
+            contextUrl: null,
+        };
+    }
+    for (const target of targets) {
+        try {
+            const result = await cdpService.call('Runtime.evaluate', {
+                expression,
+                returnByValue: true,
+                awaitPromise,
+                contextId: target.id,
+            });
+            const value = (result?.result?.value ?? null);
+            const probed = {
+                value,
+                contextId: target.id,
+                contextName: target.name ?? null,
+                contextUrl: target.url ?? null,
+            };
+            if (!firstValue)
+                firstValue = probed;
+            if (accept(value)) {
+                return probed;
+            }
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (firstValue) {
+        return firstValue;
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    return {
+        value: null,
+        contextId: null,
+        contextName: null,
+        contextUrl: null,
+    };
+}
+/**
+ * Capture the current assistant/output DOM state before sending a new prompt.
+ * This avoids races where a fast reply is mistaken for baseline text.
+ */
+async function captureResponseMonitorBaseline(cdpService) {
+    let text = null;
+    try {
+        const textResult = await evaluateAcrossContexts(cdpService, exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+        text = typeof textResult.value === 'string' ? textResult.value.trim() || null : null;
+    }
+    catch {
+        text = null;
+    }
+    const processLogKeys = new Set();
+    try {
+        const logResult = await evaluateAcrossContexts(cdpService, exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+        const logEntries = logResult.value;
+        if (Array.isArray(logEntries)) {
+            for (const entry of logEntries) {
+                const key = String(entry || '').replace(/\r/g, '').trim().slice(0, 200);
+                if (key)
+                    processLogKeys.add(key);
+            }
+        }
+    }
+    catch {
+        // best-effort baseline capture
+    }
+    return {
+        text,
+        processLogKeys: Array.from(processLogKeys),
+    };
+}
 /**
  * Lean AI response monitor.
  *
@@ -452,6 +572,8 @@ class ResponseMonitor {
     onTimeout;
     onPhaseChange;
     onProcessLog;
+    initialBaselineText;
+    initialSeenProcessLogKeys;
     pollTimer = null;
     isRunning = false;
     lastText = null;
@@ -462,6 +584,7 @@ class ResponseMonitor {
     quotaDetected = false;
     seenProcessLogKeys = new Set();
     structuredDiagLogged = false;
+    lastContentContextId = null;
     // CDP disconnect handling (#48)
     isPaused = false;
     onCdpDisconnected = null;
@@ -480,6 +603,8 @@ class ResponseMonitor {
         this.onTimeout = options.onTimeout;
         this.onPhaseChange = options.onPhaseChange;
         this.onProcessLog = options.onProcessLog;
+        this.initialBaselineText = options.initialBaselineText;
+        this.initialSeenProcessLogKeys = options.initialSeenProcessLogKeys;
     }
     /** Start monitoring */
     async start() {
@@ -508,28 +633,38 @@ class ResponseMonitor {
         this.quotaDetected = false;
         this.seenProcessLogKeys = new Set();
         this.onPhaseChange?.(this.currentPhase, null);
-        // Capture baseline text
-        try {
-            const baseResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
-            const rawValue = baseResult?.result?.value;
-            this.baselineText = typeof rawValue === 'string' ? rawValue.trim() || null : null;
-        }
-        catch {
-            this.baselineText = null;
+        if (this.initialBaselineText !== undefined) {
+            this.baselineText = this.initialBaselineText;
         }
-        // Capture baseline process logs as already-seen keys
-        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.seenProcessLogKeys = new Set(logEntries
-                    .map((s) => (s || '').replace(/\r/g, '').trim())
-                    .filter((s) => s.length > 0)
-                    .map((s) => s.slice(0, 200)));
+        else {
+            try {
+                const baseResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+                this.baselineText = typeof baseResult.value === 'string' ? baseResult.value.trim() || null : null;
+            }
+            catch {
+                this.baselineText = null;
             }
         }
-        catch {
-            // baseline capture only
+        if (this.initialSeenProcessLogKeys !== undefined) {
+            this.seenProcessLogKeys = new Set(this.initialSeenProcessLogKeys
+                .map((s) => (s || '').replace(/\r/g, '').trim())
+                .filter((s) => s.length > 0)
+                .map((s) => s.slice(0, 200)));
+        }
+        else {
+            try {
+                const logResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+                const logEntries = logResult.value;
+                if (Array.isArray(logEntries)) {
+                    this.seenProcessLogKeys = new Set(logEntries
+                        .map((s) => (s || '').replace(/\r/g, '').trim())
+                        .filter((s) => s.length > 0)
+                        .map((s) => s.slice(0, 200)));
+                }
+            }
+            catch {
+                // baseline capture only
+            }
         }
         // In structured mode, also capture activity lines from the structured
         // extraction to align the baseline with polling logic. The PROCESS_LOGS
@@ -538,8 +673,8 @@ class ResponseMonitor {
         // 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);
+                const structuredBaseline = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED, (value) => (0, assistantDomExtractor_1.classifyAssistantSegments)(value).diagnostics.source === 'dom-structured');
+                const baselineClassified = (0, assistantDomExtractor_1.classifyAssistantSegments)(structuredBaseline.value);
                 if (baselineClassified.diagnostics.source === 'dom-structured') {
                     for (const line of baselineClassified.activityLines) {
                         const key = (line || '').replace(/\r/g, '').trim().slice(0, 200);
@@ -589,12 +724,15 @@ class ResponseMonitor {
     /** Click the stop button to interrupt LLM generation */
     async clickStopButton() {
         try {
-            const result = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.CLICK_STOP_BUTTON));
-            const value = result?.result?.value;
+            const result = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.CLICK_STOP_BUTTON, (value) => !!(value && typeof value === 'object' && value.ok));
+            const value = result.value;
             if (this.isRunning) {
                 await this.stop();
             }
-            return value ?? { ok: false, error: 'CDP evaluation returned empty' };
+            if (value && typeof value.ok === 'boolean') {
+                return value;
+            }
+            return { ok: false, error: 'CDP evaluation returned empty' };
         }
         catch (error) {
             return { ok: false, error: error.message || 'Failed to click stop button' };
@@ -693,17 +831,70 @@ class ResponseMonitor {
             }
         }, this.pollIntervalMs);
     }
-    buildEvaluateParams(expression) {
-        const params = {
-            expression,
-            returnByValue: true,
+    async evaluateAcrossContexts(expression, accept) {
+        const result = await evaluateAcrossContexts(this.cdpService, expression, accept, {
             awaitPromise: true,
-        };
-        const contextId = this.cdpService.getPrimaryContextId?.();
-        if (contextId !== null && contextId !== undefined) {
-            params.contextId = contextId;
+        });
+        if (result.contextId !== null
+            && accept(result.value)
+            && this.lastContentContextId !== result.contextId) {
+            this.lastContentContextId = result.contextId;
+            logger_1.logger.debug(`[ResponseMonitor] Using context ${result.contextId} (${result.contextName ?? 'unknown'} | ${result.contextUrl ?? 'no-url'})`);
+        }
+        return result;
+    }
+    async logStructuredExtractionDiagnostics(payload) {
+        try {
+            const dumpResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.DUMP_ALL_TEXTS, (value) => Array.isArray(value) && value.length > 0);
+            const dumpValue = Array.isArray(dumpResult.value) ? dumpResult.value : [];
+            const accepted = dumpValue.filter((entry) => !entry?.skip).slice(0, 5);
+            const skipped = dumpValue.filter((entry) => entry?.skip).slice(0, 5);
+            logger_1.logger.warn(`[ResponseMonitor:diag] Structured payload invalid — ${dumpValue.length} candidate(s), ` +
+                `${accepted.length} accepted, ${skipped.length} skipped ` +
+                `(context=${dumpResult.contextId ?? 'none'})`);
+            logger_1.logger.debug('[ResponseMonitor:diag] Candidate details:', JSON.stringify({
+                payloadType: payload === null ? 'null' : typeof payload,
+                contextId: dumpResult.contextId,
+                contextUrl: dumpResult.contextUrl,
+                totalCandidates: dumpValue.length,
+                accepted: accepted.map((entry) => ({
+                    sel: entry.sel,
+                    len: entry.len,
+                    preview: entry.preview,
+                })),
+                skipped: skipped.map((entry) => ({
+                    sel: entry.sel,
+                    skip: entry.skip,
+                    len: entry.len,
+                    preview: entry.preview,
+                })),
+            }));
+        }
+        catch (error) {
+            logger_1.logger.warn('[ResponseMonitor:diag] DUMP_ALL_TEXTS failed:', error);
+        }
+        try {
+            const domResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.DOM_DIAGNOSTIC, (value) => !!value && typeof value === 'object' && (Array.isArray(value.allTextNodes)
+                || Array.isArray(value.activityNodes)
+                || Array.isArray(value.detailsDump)));
+            const domValue = domResult.value;
+            logger_1.logger.warn(`[ResponseMonitor:diag] DOM_DIAGNOSTIC — ` +
+                `details=${domValue?.detailsCount ?? 0}, ` +
+                `activity=${Array.isArray(domValue?.activityNodes) ? domValue.activityNodes.length : 0}, ` +
+                `textNodes=${Array.isArray(domValue?.allTextNodes) ? domValue.allTextNodes.length : 0} ` +
+                `(context=${domResult.contextId ?? 'none'})`);
+            logger_1.logger.debug('[ResponseMonitor:diag] DOM_DIAGNOSTIC details:', JSON.stringify({
+                contextId: domResult.contextId,
+                contextUrl: domResult.contextUrl,
+                detailsCount: domValue?.detailsCount ?? null,
+                detailsDump: Array.isArray(domValue?.detailsDump) ? domValue.detailsDump.slice(0, 3) : [],
+                activityNodes: Array.isArray(domValue?.activityNodes) ? domValue.activityNodes.slice(0, 5) : [],
+                allTextNodes: Array.isArray(domValue?.allTextNodes) ? domValue.allTextNodes.slice(0, 5) : [],
+            }));
+        }
+        catch (error) {
+            logger_1.logger.warn('[ResponseMonitor:diag] DOM_DIAGNOSTIC failed:', error);
         }
-        return params;
     }
     /**
      * Emit new process log entries, deduplicating against previously seen keys.
@@ -738,20 +929,20 @@ class ResponseMonitor {
     async poll() {
         try {
             // 1. Stop button check
-            const stopResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.STOP_BUTTON));
-            const stopValue = stopResult?.result?.value;
+            const stopResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.STOP_BUTTON, (value) => !!(value && typeof value === 'object' && value.isGenerating));
+            const stopValue = stopResult.value;
             const isGenerating = !!(stopValue && typeof stopValue === 'object' && stopValue.isGenerating);
             // 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;
+            const quotaResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.QUOTA_ERROR, (value) => value === true);
+            const quotaDetected = quotaResult.value === true;
             // 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 structuredResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED, (value) => (0, assistantDomExtractor_1.classifyAssistantSegments)(value).diagnostics.source === 'dom-structured');
+                    const payload = structuredResult.value;
                     const classified = (0, assistantDomExtractor_1.classifyAssistantSegments)(payload);
                     if (classified.diagnostics.source === 'dom-structured') {
                         currentText = classified.finalOutputText.trim() || null;
@@ -768,6 +959,7 @@ class ResponseMonitor {
                     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');
+                        await this.logStructuredExtractionDiagnostics(payload);
                     }
                 }
                 catch (error) {
@@ -776,19 +968,14 @@ class ResponseMonitor {
             }
             // 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;
+                const textResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+                currentText = typeof textResult.value === 'string' ? textResult.value.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;
+                    const logResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+                    const logEntries = logResult.value;
                     if (Array.isArray(logEntries)) {
                         this.emitNewProcessLogs(logEntries);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Control Antigravity from anywhere — a local, secure bot (Discord + Telegram) that lets you remotely operate Antigravity on your home PC from your smartphone.",
   "main": "dist/index.js",
   "bin": {