lazy-gravity 0.6.1 → 0.7.0

package/dist/services/chatSessionService.js

@@ -30,6 +30,56 @@ const GET_CHAT_TITLE_SCRIPT = `(() => {
     const hasActiveChat = title.length > 0 && title !== 'Agent';
     return { title: title || '(Untitled)', hasActiveChat };
 })()`;
+const GET_SESSION_VIEW_STATE_SCRIPT = `(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) {
+        return {
+            panelFound: false,
+            title: '',
+            hasActiveChat: false,
+            hasLoadingIndicator: false,
+            hasRenderableContent: false,
+            renderablePreview: [],
+        };
+    }
+    const header = panel.querySelector('div[class*="border-b"]');
+    const titleEl = header?.querySelector('div[class*="text-ellipsis"]');
+    const title = titleEl ? (titleEl.textContent || '').trim() : '';
+    const hasActiveChat = title.length > 0 && title !== 'Agent';
+
+    const bodyCandidates = Array.from(panel.querySelectorAll(
+        '[data-message-author-role], [data-message-role], .rendered-markdown, .prose'
+    ));
+    const renderablePreview = bodyCandidates.filter((el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const text = (el.textContent || '').trim();
+        if (el.offsetParent === null || text.length === 0) return false;
+        if (/^\\/\\*\\s*Copied from /i.test(text)) return false;
+        return true;
+    }).slice(0, 5).map((el) => ({
+        tag: el.tagName,
+        className: el.className || '',
+        text: ((el.textContent || '').trim()).slice(0, 160),
+    }));
+    const hasRenderableContent = renderablePreview.length > 0;
+
+    const hasLoadingIndicator = Boolean(
+        panel.querySelector(
+            '[role="progressbar"], ' +
+            'svg[class*="animate-spin"], div[class*="animate-spin"], ' +
+            'svg[class*="spinner"], div[class*="spinner"], div[class*="loading"]'
+        )
+    );
+
+    return {
+        panelFound: true,
+        title: title || '(Untitled)',
+        hasActiveChat,
+        hasLoadingIndicator,
+        hasRenderableContent,
+        renderablePreview,
+    };
+})()`;
 /**
  * Script to find the Past Conversations button and return its coordinates.
  * We use coordinates so that the actual click is done via CDP Input.dispatchMouseEvent,
@@ -432,6 +482,10 @@ class ChatSessionService {
     static ACTIVATE_SESSION_MAX_WAIT_MS = 30000;
     static ACTIVATE_SESSION_RETRY_INTERVAL_MS = 800;
     static LIST_SESSIONS_TARGET = 20;
+    static HYDRATE_RETRY_DELAY_MS = 700;
+    static REOPEN_RETRY_ATTEMPTS = 4;
+    static REOPEN_NEW_CHAT_DELAY_MS = 400;
+    static REOPEN_HISTORY_DELAY_MS = 1000;
     /**
      * List recent sessions by opening the Past Conversations panel.
      *
@@ -556,6 +610,25 @@ class ChatSessionService {
             type: 'mouseReleased', x, y, button: 'left', clickCount: 1,
         });
     }
+    async dispatchNewConversationShortcut(cdpService) {
+        const modifiers = process.platform === 'darwin' ? 8 : 10;
+        await cdpService.call('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: 'L',
+            code: 'KeyL',
+            modifiers,
+            windowsVirtualKeyCode: 76,
+            nativeVirtualKeyCode: 76,
+        });
+        await cdpService.call('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: 'L',
+            code: 'KeyL',
+            modifiers,
+            windowsVirtualKeyCode: 76,
+            nativeVirtualKeyCode: 76,
+        });
+    }
     /**
      * Start a new chat session in the Antigravity UI.
      *
@@ -597,27 +670,23 @@ class ChatSessionService {
             if (!btnState.enabled) {
                 return { ok: true };
             }
-            // cursor: pointer -> click via CDP Input API coordinates
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mouseMoved', x: btnState.x, y: btnState.y,
-            });
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mousePressed', x: btnState.x, y: btnState.y,
-                button: 'left', clickCount: 1,
-            });
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mouseReleased', x: btnState.x, y: btnState.y,
-                button: 'left', clickCount: 1,
-            });
-            // Wait for UI to update after click
+            // Prefer the keyboard shortcut because some Antigravity builds bind hover tips to the button target.
+            await this.dispatchNewConversationShortcut(cdpService);
+            // Wait for UI to update after shortcut
             await new Promise(r => setTimeout(r, 1500));
             // Check if button changed to not-allowed (evidence that a new chat was opened)
             const afterState = await this.getNewChatButtonState(cdpService, contexts);
             if (afterState.found && !afterState.enabled) {
                 return { ok: true };
             }
-            // Button still enabled -> click may not have worked
-            return { ok: false, error: 'Clicked new chat button but state did not change' };
+            // Fallback for older builds where the shortcut is not wired.
+            await this.cdpMouseClick(cdpService, btnState.x, btnState.y);
+            await new Promise(r => setTimeout(r, 1500));
+            const afterFallback = await this.getNewChatButtonState(cdpService, contexts);
+            if (afterFallback.found && !afterFallback.enabled) {
+                return { ok: true };
+            }
+            return { ok: false, error: 'New conversation shortcut and button click did not change state' };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -655,6 +724,104 @@ class ChatSessionService {
             return { title: '(Failed to retrieve)', hasActiveChat: false };
         }
     }
+    async getCurrentSessionViewState(cdpService) {
+        try {
+            const contexts = cdpService.getContexts();
+            for (const ctx of contexts) {
+                try {
+                    const result = await cdpService.call('Runtime.evaluate', {
+                        expression: GET_SESSION_VIEW_STATE_SCRIPT,
+                        returnByValue: true,
+                        contextId: ctx.id,
+                    });
+                    const value = result?.result?.value;
+                    const hasPanel = value?.panelFound === true;
+                    const looksUseful = Boolean(hasPanel ||
+                        value?.hasLoadingIndicator ||
+                        value?.hasRenderableContent ||
+                        (typeof value?.title === 'string' && value.title.trim().length > 0));
+                    if (value && looksUseful) {
+                        return {
+                            title: value.title,
+                            hasActiveChat: value.hasActiveChat ?? false,
+                            panelFound: value.panelFound ?? false,
+                            hasLoadingIndicator: value.hasLoadingIndicator ?? false,
+                            hasRenderableContent: value.hasRenderableContent ?? false,
+                            renderablePreview: Array.isArray(value.renderablePreview) ? value.renderablePreview : [],
+                        };
+                    }
+                }
+                catch (_) { /* try next context */ }
+            }
+        }
+        catch (_) { /* fall through */ }
+        return {
+            title: '(Failed to retrieve)',
+            hasActiveChat: false,
+            panelFound: false,
+            hasLoadingIndicator: false,
+            hasRenderableContent: false,
+            renderablePreview: [],
+        };
+    }
+    async refreshSessionViewIfStuck(cdpService, title) {
+        const state = await this.getCurrentSessionViewState(cdpService);
+        if (state.title.trim() !== title.trim()) {
+            return { ok: false, error: `Current title mismatch before refresh (expected="${title}", actual="${state.title}")` };
+        }
+        if (!state.hasLoadingIndicator && state.hasRenderableContent) {
+            return { ok: true };
+        }
+        const bounce = await this.recoverSessionViewWithNewConversationBounce(cdpService, title);
+        if (bounce.ok) {
+            return bounce;
+        }
+        return {
+            ok: false,
+            error: `Session "${title}" still appears stuck after new-conversation recovery ` +
+                `(${bounce.error || 'unknown'})`,
+        };
+    }
+    async recoverSessionViewWithNewConversationBounce(cdpService, title, options) {
+        const state = await this.getCurrentSessionViewState(cdpService);
+        if (state.title.trim() === title.trim() && !state.hasLoadingIndicator && state.hasRenderableContent) {
+            return { ok: true };
+        }
+        const maxAttempts = options?.maxAttempts ?? ChatSessionService.REOPEN_RETRY_ATTEMPTS;
+        const newChatDelayMs = options?.newChatDelayMs ?? ChatSessionService.REOPEN_NEW_CHAT_DELAY_MS;
+        const reopenDelayMs = options?.reopenDelayMs ?? ChatSessionService.REOPEN_HISTORY_DELAY_MS;
+        let lastError = `Session "${title}" still appears stuck before recovery`;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const newChat = await this.startNewChat(cdpService);
+            if (!newChat.ok) {
+                lastError =
+                    `Attempt ${attempt}/${maxAttempts}: failed to open a fresh new conversation before reopening "${title}": ` +
+                        `${newChat.error || 'unknown'}`;
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, newChatDelayMs));
+            const reopened = await this.activateSessionByTitle(cdpService, title, {
+                maxWaitMs: 8000,
+                retryIntervalMs: 300,
+                allowVisibilityWarmupMs: 1000,
+            });
+            if (!reopened.ok) {
+                lastError =
+                    `Attempt ${attempt}/${maxAttempts}: failed to reopen "${title}" after new conversation: ` +
+                        `${reopened.error || 'unknown'}`;
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, reopenDelayMs));
+            const after = await this.getCurrentSessionViewState(cdpService);
+            if (after.title.trim() === title.trim() && (!after.hasLoadingIndicator || after.hasRenderableContent)) {
+                return { ok: true };
+            }
+            lastError =
+                `Attempt ${attempt}/${maxAttempts}: session "${title}" still appears stuck after reopening ` +
+                    `(loading=${after.hasLoadingIndicator}, content=${after.hasRenderableContent}, actual="${after.title}")`;
+        }
+        return { ok: false, error: lastError };
+    }
     /**
      * Activate an existing chat by title.
      * Returns ok:false if the target chat cannot be located or verified.
@@ -669,12 +836,14 @@ class ChatSessionService {
         }
         const maxWaitMs = options?.maxWaitMs ?? ChatSessionService.ACTIVATE_SESSION_MAX_WAIT_MS;
         const retryIntervalMs = options?.retryIntervalMs ?? ChatSessionService.ACTIVATE_SESSION_RETRY_INTERVAL_MS;
+        const allowVisibilityWarmupMs = options?.allowVisibilityWarmupMs ?? 0;
         let usedPastConversations = false;
         let directResult = { ok: false, error: 'not attempted' };
         let pastResult = null;
         let clicked = false;
-        const startedAt = Date.now();
+        let startedAt = Date.now();
         let attempts = 0;
+        let warmupConsumed = false;
         while (Date.now() - startedAt <= maxWaitMs) {
             attempts += 1;
             directResult = await this.tryActivateByDirectSidePanel(cdpService, title);
@@ -704,8 +873,21 @@ class ChatSessionService {
         await new Promise((resolve) => setTimeout(resolve, 500));
         const after = await this.getCurrentSessionInfo(cdpService);
         if (after.title.trim() === title.trim()) {
+            if (usedPastConversations) {
+                await this.closePanelWithEscape(cdpService);
+            }
             return { ok: true };
         }
+        if (!warmupConsumed && allowVisibilityWarmupMs > 0 && after.title.trim() === 'Agent') {
+            warmupConsumed = true;
+            startedAt = Date.now();
+            await new Promise((resolve) => setTimeout(resolve, allowVisibilityWarmupMs));
+            return this.activateSessionByTitle(cdpService, title, {
+                maxWaitMs,
+                retryIntervalMs,
+                allowVisibilityWarmupMs: 0,
+            });
+        }
         // If direct side-panel activation hit the wrong row, try the explicit Past Conversations flow.
         if (!usedPastConversations) {
             const viaPast = await this.tryActivateByPastConversations(cdpService, title);
@@ -713,6 +895,7 @@ class ChatSessionService {
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 const afterPast = await this.getCurrentSessionInfo(cdpService);
                 if (afterPast.title.trim() === title.trim()) {
+                    await this.closePanelWithEscape(cdpService);
                     return { ok: true };
                 }
                 return {

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);
                     }