lazy-gravity 0.9.2 → 0.10.0

package/dist/services/notificationSender.js

@@ -6,6 +6,7 @@
  * They return a `MessagePayload` that any platform adapter can render.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUESTION_SKIP_ACTION_PREFIX = exports.QUESTION_SELECT_ACTION_PREFIX = exports.FEEDBACK_ACTION_PREFIX = void 0;
 exports.buildApprovalNotification = buildApprovalNotification;
 exports.buildPlanningNotification = buildPlanningNotification;
 exports.buildErrorPopupNotification = buildErrorPopupNotification;
@@ -13,6 +14,7 @@ exports.buildRunCommandNotification = buildRunCommandNotification;
 exports.buildAutoApprovedNotification = buildAutoApprovedNotification;
 exports.buildResolvedOverlay = buildResolvedOverlay;
 exports.buildStatusNotification = buildStatusNotification;
+exports.buildQuestionNotification = buildQuestionNotification;
 exports.buildProgressNotification = buildProgressNotification;
 const richContentBuilder_1 = require("../platform/richContentBuilder");
 // ---------------------------------------------------------------------------
@@ -28,6 +30,9 @@ const ERROR_POPUP_COPY_DEBUG_ACTION_PREFIX = 'error_popup_copy_debug_action';
 const ERROR_POPUP_RETRY_ACTION_PREFIX = 'error_popup_retry_action';
 const RUN_COMMAND_RUN_ACTION_PREFIX = 'run_command_run_action';
 const RUN_COMMAND_REJECT_ACTION_PREFIX = 'run_command_reject_action';
+exports.FEEDBACK_ACTION_PREFIX = 'feedback_action';
+exports.QUESTION_SELECT_ACTION_PREFIX = 'question_select_action';
+exports.QUESTION_SKIP_ACTION_PREFIX = 'question_skip_action';
 // ---------------------------------------------------------------------------
 // Notification colours
 // ---------------------------------------------------------------------------
@@ -77,14 +82,21 @@ function customId(prefix, projectName, channelId) {
 // ---------------------------------------------------------------------------
 /** Build the approval notification message. */
 function buildApprovalNotification(opts) {
-    const { title, description, projectName, channelId, toolNames, extraFields } = opts;
+    const { title, description, projectName, channelId, toolNames, extraFields, hasAlwaysAllow, alwaysAllowText } = opts;
     const richContent = (0, richContentBuilder_1.pipe)((0, richContentBuilder_1.createRichContent)(), (rc) => (0, richContentBuilder_1.withTitle)(rc, title), (rc) => (0, richContentBuilder_1.withDescription)(rc, description), (rc) => (0, richContentBuilder_1.withColor)(rc, COLOR_APPROVAL), (rc) => (0, richContentBuilder_1.addField)(rc, 'Project', projectName, true), (rc) => toolNames && toolNames.length > 0
         ? (0, richContentBuilder_1.addField)(rc, 'Tools', toolNames.join(', '), true)
         : rc, (rc) => extraFields
         ? extraFields.reduce((acc, f) => (0, richContentBuilder_1.addField)(acc, f.name, f.value, f.inline), rc)
         : rc, (rc) => (0, richContentBuilder_1.withFooter)(rc, 'Approval required'), (rc) => (0, richContentBuilder_1.withTimestamp)(rc));
+    const buttons = [
+        button(customId(APPROVE_ACTION_PREFIX, projectName, channelId), 'Allow', 'success'),
+    ];
+    if (hasAlwaysAllow) {
+        buttons.push(button(customId(ALWAYS_ALLOW_ACTION_PREFIX, projectName, channelId), alwaysAllowText || 'Allow Chat', 'primary'));
+    }
+    buttons.push(button(customId(DENY_ACTION_PREFIX, projectName, channelId), 'Deny', 'danger'));
     const components = [
-        buttonRow(button(customId(APPROVE_ACTION_PREFIX, projectName, channelId), 'Allow', 'success'), button(customId(ALWAYS_ALLOW_ACTION_PREFIX, projectName, channelId), 'Allow Chat', 'primary'), button(customId(DENY_ACTION_PREFIX, projectName, channelId), 'Deny', 'danger')),
+        buttonRow(...buttons),
     ];
     return { richContent, components };
 }
@@ -94,8 +106,15 @@ function buildPlanningNotification(opts) {
     const richContent = (0, richContentBuilder_1.pipe)((0, richContentBuilder_1.createRichContent)(), (rc) => (0, richContentBuilder_1.withTitle)(rc, title), (rc) => (0, richContentBuilder_1.withDescription)(rc, description), (rc) => (0, richContentBuilder_1.withColor)(rc, COLOR_PLANNING), (rc) => extraFields
         ? extraFields.reduce((acc, f) => (0, richContentBuilder_1.addField)(acc, f.name, f.value, f.inline), rc)
         : rc, (rc) => (0, richContentBuilder_1.withFooter)(rc, 'Planning mode detected'), (rc) => (0, richContentBuilder_1.withTimestamp)(rc));
+    const buttons = [];
+    const openLabel = opts.openText || 'Open';
+    if (opts.hasOpenButton !== false) {
+        buttons.push(button(customId(PLANNING_OPEN_ACTION_PREFIX, projectName, channelId), openLabel, 'primary'));
+    }
+    const buttonLabel = opts.proceedText || 'Proceed';
+    buttons.push(button(customId(PLANNING_PROCEED_ACTION_PREFIX, projectName, channelId), buttonLabel, 'success'));
     const components = [
-        buttonRow(button(customId(PLANNING_OPEN_ACTION_PREFIX, projectName, channelId), 'Open', 'primary'), button(customId(PLANNING_PROCEED_ACTION_PREFIX, projectName, channelId), 'Proceed', 'success')),
+        buttonRow(...buttons),
     ];
     return { richContent, components };
 }
@@ -158,6 +177,54 @@ function buildStatusNotification(opts) {
         : rc);
     return { richContent };
 }
+function buildQuestionNotification(params) {
+    const { title, description, projectName, channelId, options } = params;
+    const baseContent = (0, richContentBuilder_1.pipe)((0, richContentBuilder_1.createRichContent)(), (rc) => (0, richContentBuilder_1.withTitle)(rc, title), (rc) => (0, richContentBuilder_1.withColor)(rc, COLOR_APPROVAL));
+    const embed = description ? (0, richContentBuilder_1.withDescription)(baseContent, description) : baseContent;
+    const selectMenuOptions = options.map((opt, i) => ({
+        label: opt.text.substring(0, 100), // Discord max length for label is 100
+        value: i.toString(),
+    })).slice(0, 25); // Discord max options in a select menu is 25
+    // Ensure customIds fit within 100 chars without losing channelId
+    const encodeSafe = (str, maxLen) => {
+        let encoded = encodeURIComponent(str);
+        if (encoded.length <= maxLen)
+            return encoded;
+        return encoded.substring(0, maxLen).replace(/(%[0-9A-F]?)$/i, '');
+    };
+    const encodedChannel = encodeURIComponent(channelId);
+    const selectOverhead = exports.QUESTION_SELECT_ACTION_PREFIX.length + 2 + encodedChannel.length;
+    const safeSelectProjectName = encodeSafe(projectName, 100 - selectOverhead);
+    const encodedCustomId = `${exports.QUESTION_SELECT_ACTION_PREFIX}:${safeSelectProjectName}:${encodedChannel}`;
+    const skipOverhead = exports.QUESTION_SKIP_ACTION_PREFIX.length + 2 + encodedChannel.length;
+    const safeSkipProjectName = encodeSafe(projectName, 100 - skipOverhead);
+    const encodedSkipCustomId = `${exports.QUESTION_SKIP_ACTION_PREFIX}:${safeSkipProjectName}:${encodedChannel}`;
+    return {
+        richContent: embed,
+        components: [
+            {
+                components: [
+                    {
+                        type: 'selectMenu',
+                        customId: encodedCustomId,
+                        placeholder: 'Select an option...',
+                        options: selectMenuOptions,
+                    },
+                ],
+            },
+            {
+                components: [
+                    {
+                        type: 'button',
+                        customId: encodedSkipCustomId,
+                        label: 'Skip',
+                        style: 'secondary',
+                    },
+                ],
+            },
+        ],
+    };
+}
 /** Build a progress / phase notification (e.g. "Thinking...", "Generating..."). */
 function buildProgressNotification(opts) {
     const { phase, projectName, detail } = opts;

package/dist/services/planningDetector.js

@@ -10,33 +10,59 @@ const approvalDetector_1 = require("./approvalDetector");
  * and extracts plan metadata from the surrounding DOM elements.
  */
 const DETECT_PLANNING_SCRIPT = `(() => {
-    const OPEN_PATTERNS = ['open'];
+    const OPEN_PATTERNS = ['open', 'review'];
     const PROCEED_PATTERNS = ['proceed'];
+    const REJECT_PATTERNS = ['reject'];
+    const ACCEPT_PATTERNS = ['accept'];
 
     const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
 
-    // Find the notify container that holds planning UI
-    const container = document.querySelector('.notify-user-container');
-    if (!container) return null;
+    const allButtons = Array.from(document.querySelectorAll('button, a'))
+        .filter(btn => btn.offsetParent !== null)
+        .reverse();
 
-    const allButtons = Array.from(container.querySelectorAll('button'))
-        .filter(btn => btn.offsetParent !== null);
+    let proceedBtn = null;
+    let openBtn = null;
+    let rejectBtn = null;
 
-    const openBtn = allButtons.find(btn => {
+    for (const btn of allButtons) {
         const t = normalize(btn.textContent || '');
-        return OPEN_PATTERNS.some(p => t === p || t.includes(p));
-    }) || null;
+        if (t.includes('review changes')) continue; // Ignore file change review button
 
-    const proceedBtn = allButtons.find(btn => {
-        const t = normalize(btn.textContent || '');
-        return PROCEED_PATTERNS.some(p => t === p || t.includes(p));
-    }) || null;
+        // If we hit an accept or reject button before finding a proceed button, 
+        // it means the most recent state is an Approval, not Planning.
+        if (!proceedBtn && (ACCEPT_PATTERNS.some(p => t === p || t.includes(p)) || REJECT_PATTERNS.some(p => t === p || t.includes(p)))) {
+            return null;
+        }
+
+        if (!proceedBtn && PROCEED_PATTERNS.some(p => t === p || t.includes(p))) {
+            proceedBtn = btn;
+            continue;
+        }
+
+        if (!openBtn && OPEN_PATTERNS.some(p => t === p || t.includes(p))) {
+            openBtn = btn;
+        }
+
+        if (!rejectBtn && REJECT_PATTERNS.some(p => t === p || t.includes(p))) {
+            rejectBtn = btn;
+        }
+        
+        if (proceedBtn && openBtn) break;
+    }
 
-    // Both buttons must exist for this to be a planning UI
-    if (!openBtn || !proceedBtn) return null;
+    // Proceed button must exist for this to be a planning UI
+    if (!proceedBtn) return null;
+    
+    const container = proceedBtn.closest('.notify-user-container') || proceedBtn.closest('div[class*="rounded-lg"]') || proceedBtn.parentElement?.parentElement;
+    if (!container) return null;
 
-    const openText = (openBtn.textContent || '').trim();
+    // openBtn was already extracted in the loop above
+
+    const hasOpenButton = openBtn !== null;
+    const openText = openBtn ? (openBtn.textContent || '').trim() : 'Open';
     const proceedText = (proceedBtn.textContent || '').trim();
+    const rejectText = rejectBtn ? (rejectBtn.textContent || '').trim() : '';
 
     // Extract plan title from .inline-flex.break-all
     const titleEl = container.querySelector('span.inline-flex.break-all, .inline-flex.break-all');
@@ -67,7 +93,7 @@ const DETECT_PLANNING_SCRIPT = `(() => {
         description = parts.join(' ').slice(0, 500);
     }
 
-    return { openText, proceedText, planTitle, planSummary, description };
+    return { openText, proceedText, planTitle, planSummary, description, rejectText, hasOpenButton };
 })()`;
 /**
  * Extract plan content displayed after clicking Open.
@@ -158,8 +184,12 @@ class PlanningDetector {
     lastDetectedInfo = null;
     /** Timestamp of last notification (for cooldown-based dedup) */
     lastNotifiedAt = 0;
+    /** Number of consecutive polls without detecting buttons */
+    emptyPollCount = 0;
     /** Cooldown period in ms to suppress duplicate notifications */
     static COOLDOWN_MS = 5000;
+    /** Number of consecutive empty polls required before resetting state */
+    static REQUIRED_EMPTY_POLLS = 3;
     constructor(options) {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
@@ -174,6 +204,7 @@ class PlanningDetector {
         this.lastDetectedKey = null;
         this.lastDetectedInfo = null;
         this.lastNotifiedAt = 0;
+        this.emptyPollCount = 0;
         this.schedulePoll();
     }
     /** Stop monitoring. */
@@ -210,6 +241,15 @@ class PlanningDetector {
         const text = buttonText ?? this.lastDetectedInfo?.proceedText ?? 'Proceed';
         return this.clickButton(text);
     }
+    /**
+     * Click the Reject button via CDP.
+     * @param buttonText Text of the button to click (default: detected rejectText or "Reject All")
+     * @returns true if click succeeded
+     */
+    async clickRejectButton(buttonText) {
+        const text = buttonText ?? this.lastDetectedInfo?.rejectText ?? 'Reject All';
+        return this.clickButton(text);
+    }
     /**
      * Extract plan content from the DOM after Open has been clicked.
      * @returns Plan content text or null if not found
@@ -255,8 +295,9 @@ class PlanningDetector {
             const result = await this.cdpService.call('Runtime.evaluate', callParams);
             const info = result?.result?.value ?? null;
             if (info) {
-                // Duplicate prevention: use button text pair as key (stable across DOM redraws)
-                const key = `${info.openText}::${info.proceedText}`;
+                this.emptyPollCount = 0;
+                // Duplicate prevention: use plan title and content as key (stable across DOM redraws and button text updates)
+                const key = `${info.planTitle}::${info.planSummary}::${(info.description || '').substring(0, 50)}`;
                 const now = Date.now();
                 const withinCooldown = (now - this.lastNotifiedAt) < PlanningDetector.COOLDOWN_MS;
                 if (key !== this.lastDetectedKey && !withinCooldown) {
@@ -271,12 +312,15 @@ class PlanningDetector {
                 }
             }
             else {
-                // Reset when buttons disappear (prepare for next planning detection)
-                const wasDetected = this.lastDetectedKey !== null;
-                this.lastDetectedKey = null;
-                this.lastDetectedInfo = null;
-                if (wasDetected && this.onResolved) {
-                    this.onResolved();
+                this.emptyPollCount++;
+                if (this.emptyPollCount >= PlanningDetector.REQUIRED_EMPTY_POLLS) {
+                    // Reset when buttons disappear for consecutive polls
+                    const wasDetected = this.lastDetectedKey !== null;
+                    this.lastDetectedKey = null;
+                    this.lastDetectedInfo = null;
+                    if (wasDetected && this.onResolved) {
+                        this.onResolved();
+                    }
                 }
             }
         }

package/dist/services/promptDispatcher.js

@@ -11,7 +11,13 @@ class PromptDispatcher {
         this.deps = deps;
     }
     async send(req) {
-        await this.deps.sendPromptImpl(this.deps.bridge, req.message, req.prompt, req.cdp, this.deps.modeService, this.deps.modelService, req.inboundImages ?? [], req.options);
+        await this._dispatch(req, req.options);
+    }
+    async resume(req) {
+        await this._dispatch(req, { ...req.options, resumeOnly: true });
+    }
+    async _dispatch(req, options) {
+        await this.deps.sendPromptImpl(this.deps.bridge, req.message, req.prompt, req.cdp, this.deps.modeService, this.deps.modelService, req.inboundImages ?? [], options);
     }
 }
 exports.PromptDispatcher = PromptDispatcher;

package/dist/services/questionDetector.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionDetector = void 0;
+const events_1 = require("events");
+const logger_1 = require("../utils/logger");
+class QuestionDetector extends events_1.EventEmitter {
+    cdp;
+    pollIntervalMs;
+    intervalId = null;
+    logger = logger_1.logger;
+    lastQuestionDetected = false;
+    emptyPollCount = 0;
+    static REQUIRED_EMPTY_POLLS = 3;
+    _isStarted = false;
+    onQuestionRequired;
+    onResolved;
+    projectName = 'unknown';
+    constructor(options) {
+        super();
+        this.cdp = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs || 2000;
+        this.onQuestionRequired = options.onQuestionRequired;
+        this.onResolved = options.onResolved;
+        // Listen to own events to call options callbacks (for compat)
+        this.on('question', (info) => this.onQuestionRequired(info));
+        this.on('resolved', () => {
+            if (this.onResolved)
+                this.onResolved();
+        });
+    }
+    setProjectName(name) {
+        this.projectName = name;
+    }
+    get isActive() {
+        return this._isStarted;
+    }
+    start() {
+        if (this._isStarted)
+            return;
+        this._isStarted = true;
+        this.logger.debug(`[QuestionDetector:${this.projectName}] Starting polling`);
+        this.lastQuestionDetected = false;
+        this.emptyPollCount = 0;
+        this.intervalId = setInterval(() => this.poll(), this.pollIntervalMs);
+        this.poll();
+    }
+    stop() {
+        if (!this._isStarted)
+            return;
+        this._isStarted = false;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.logger.debug(`[QuestionDetector:${this.projectName}] Stopped polling`);
+    }
+    async submitOption(index) {
+        this.logger.debug(`[QuestionDetector:${this.projectName}] Submitting option ${index}`);
+        try {
+            const contextId = this.cdp.getPrimaryContextId();
+            const callParams = {
+                expression: `
+                (() => {
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let targetList = null;
+                    let submitBtn = null;
+                    
+                    for (const container of containers) {
+                        const buttons = Array.from(container.querySelectorAll('button'));
+                        let possibleSubmitBtn = null;
+                        for (const btn of buttons) {
+                            const text = btn.textContent?.toLowerCase() || '';
+                            if (text.includes('submit')) {
+                                possibleSubmitBtn = btn;
+                                break;
+                            }
+                        }
+                        
+                        if (possibleSubmitBtn) {
+                            const items = Array.from(container.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                                .filter(el => el.tagName !== 'BUTTON' && !el.closest('button'));
+                            
+                            if (items.length > 1) {
+                                targetList = container;
+                                submitBtn = possibleSubmitBtn;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!targetList || !submitBtn) return { found: false };
+
+                    const items = Array.from(targetList.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                        .filter(el => el.tagName !== 'BUTTON' && !el.closest('button'));
+                    if (items.length <= ${index}) return { found: false };
+                    
+                    const targetOption = items[${index}];
+                    
+                    const optionRect = targetOption.getBoundingClientRect();
+                    const btnRect = submitBtn.getBoundingClientRect();
+                    
+                    return {
+                        found: true,
+                        option: {
+                            x: Math.round(optionRect.left + optionRect.width / 2),
+                            y: Math.round(optionRect.top + optionRect.height / 2)
+                        },
+                        button: {
+                            x: Math.round(btnRect.left + btnRect.width / 2),
+                            y: Math.round(btnRect.top + btnRect.height / 2)
+                        }
+                    };
+                })()
+                `,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null) {
+                callParams.contextId = contextId;
+            }
+            const response = await this.cdp.call('Runtime.evaluate', callParams);
+            const result = response?.result?.value;
+            if (!result || !result.found) {
+                this.logger.warn(`[QuestionDetector:${this.projectName}] Could not find question modal elements during submission.`);
+                return false;
+            }
+            // Click the option
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mousePressed',
+                x: result.option.x,
+                y: result.option.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mouseReleased',
+                x: result.option.x,
+                y: result.option.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Click the submit button
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mousePressed',
+                x: result.button.x,
+                y: result.button.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mouseReleased',
+                x: result.button.x,
+                y: result.button.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            this.lastQuestionDetected = false;
+            return true;
+        }
+        catch (e) {
+            this.logger.error(`[QuestionDetector:${this.projectName}] submitOption error:`, e.message);
+            return false;
+        }
+    }
+    async skipQuestion() {
+        this.logger.debug(`[QuestionDetector:${this.projectName}] Skipping question`);
+        try {
+            const contextId = this.cdp.getPrimaryContextId();
+            const callParams = {
+                expression: `
+                (() => {
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let skipBtn = null;
+                    
+                    for (const container of containers) {
+                        const items = Array.from(container.querySelectorAll('li, [role="radio"], [role="option"], .cursor-pointer'))
+                            .filter(el => el.tagName !== 'BUTTON' && !el.closest('button'));
+                        const hasList = items.length > 1;
+                        
+                        const buttons = Array.from(container.querySelectorAll('button'));
+                        for (const btn of buttons) {
+                            const text = btn.textContent?.toLowerCase() || '';
+                            if (text.includes('skip') && hasList) {
+                                skipBtn = btn;
+                                break;
+                            }
+                        }
+                        if (skipBtn) break;
+                    }
+
+                    if (!skipBtn) return { found: false };
+                    
+                    const btnRect = skipBtn.getBoundingClientRect();
+                    return {
+                        found: true,
+                        button: {
+                            x: Math.round(btnRect.left + btnRect.width / 2),
+                            y: Math.round(btnRect.top + btnRect.height / 2)
+                        }
+                    };
+                })()
+                `,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const response = await this.cdp.call('Runtime.evaluate', callParams);
+            const result = response?.result?.value;
+            if (!result || !result.found) {
+                this.logger.warn(`[QuestionDetector:${this.projectName}] Could not find skip button.`);
+                return false;
+            }
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mousePressed',
+                x: result.button.x,
+                y: result.button.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            await this.cdp.call('Input.dispatchMouseEvent', {
+                type: 'mouseReleased',
+                x: result.button.x,
+                y: result.button.y,
+                button: 'left',
+                clickCount: 1,
+            });
+            this.lastQuestionDetected = false;
+            return true;
+        }
+        catch (e) {
+            this.logger.error(`[QuestionDetector:${this.projectName}] skipQuestion error:`, e.message);
+            return false;
+        }
+    }
+    async poll() {
+        if (!this.cdp.isConnected())
+            return;
+        try {
+            const callParams = {
+                expression: `
+                (() => {
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let targetList = null;
+                    let submitBtn = null;
+                    
+                    for (const container of containers) {
+                        const buttons = Array.from(container.querySelectorAll('button'));
+                        let possibleSubmitBtn = null;
+                        for (const btn of buttons) {
+                            const text = btn.textContent?.toLowerCase() || '';
+                            if (text.includes('submit')) {
+                                possibleSubmitBtn = btn;
+                                break;
+                            }
+                        }
+                        
+                        if (possibleSubmitBtn) {
+                            const items = Array.from(container.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                                .filter(el => el.tagName !== 'BUTTON' && !el.closest('button'));
+                            
+                            if (items.length > 1) {
+                                targetList = container;
+                                submitBtn = possibleSubmitBtn;
+                                break;
+                            }
+                        }
+                    }
+                    if (!targetList || !submitBtn) return { detected: false, reason: "No targetList or submitBtn found" };
+
+                    let titleEl = targetList.querySelector('h1, h2, h3, [role="heading"], .text-lg');
+                    if (!titleEl) {
+                        let p = targetList;
+                        while (p && p.tagName !== 'BODY') {
+                            titleEl = p.querySelector('h1, h2, h3, [role="heading"], .text-lg, p');
+                            if (titleEl && titleEl !== p && (titleEl.innerText || titleEl.textContent || '').trim().length > 0) break;
+                            p = p.parentElement;
+                        }
+                    }
+                    const title = titleEl ? (titleEl.innerText || titleEl.textContent || '').trim() : 'Question';
+                    
+                    const items = Array.from(targetList.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                        .filter(el => el.tagName !== 'BUTTON' && !el.closest('button'));
+                    const options = items.map(n => {
+                        const rect = n.getBoundingClientRect();
+                        const finalLabel = n.innerText || n.textContent || 'Option';
+
+                        return {
+                            text: finalLabel.replace(/\\n/g, ' ').replace(/\\s+/g, ' ').trim().substring(0, 100),
+                            x: Math.round(rect.left + rect.width / 2),
+                            y: Math.round(rect.top + rect.height / 2)
+                        };
+                    });
+
+                    if (options.length === 0) return { detected: false, reason: "options length 0" };
+
+                    return {
+                        detected: true,
+                        title,
+                        options
+                    };
+                })()
+                `,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            const contexts = this.cdp.getContexts();
+            const contextIds = [
+                this.cdp.getPrimaryContextId(),
+                ...contexts.map((ctx) => ctx.id),
+            ].filter((value, index, arr) => typeof value === 'number' && arr.indexOf(value) === index);
+            const targets = contextIds.length > 0 ? contextIds : [null];
+            let detectedResult = null;
+            let lastReason = null;
+            for (const contextId of targets) {
+                if (contextId !== null) {
+                    callParams.contextId = contextId;
+                }
+                const response = await this.cdp.call('Runtime.evaluate', callParams).catch(e => {
+                    this.logger.debug(`[QuestionDetector] Error evaluating on ctx ${contextId}: ${e.message}`);
+                    return null;
+                });
+                if (response?.exceptionDetails) {
+                    this.logger.debug(`[QuestionDetector] Exception on ctx ${contextId}: ${response.exceptionDetails.exception?.description || response.exceptionDetails.text}`);
+                }
+                const result = response?.result?.value;
+                if (result) {
+                    this.logger.debug(`[QuestionDetector] Context ${contextId} evaluated successfully, detected: ${result.detected}, reason: ${result.reason}`);
+                }
+                if (result && result.detected) {
+                    detectedResult = result;
+                    break;
+                }
+                else if (result && result.reason) {
+                    lastReason = result.reason;
+                }
+            }
+            const result = detectedResult;
+            if (result && result.detected) {
+                this.emptyPollCount = 0;
+                if (!this.lastQuestionDetected) {
+                    this.lastQuestionDetected = true;
+                    this.logger.debug(`[QuestionDetector:${this.projectName}] Question modal detected`);
+                    this.emit('question', {
+                        title: result.title || 'Question',
+                        description: 'Please answer the question below.',
+                        options: result.options,
+                    });
+                }
+            }
+            else {
+                if (!result && lastReason) {
+                    this.logger.debug(`[QuestionDetector:${this.projectName}] Evaluate returned false: ${lastReason}`);
+                }
+                this.emptyPollCount++;
+                if (this.emptyPollCount >= QuestionDetector.REQUIRED_EMPTY_POLLS) {
+                    if (this.lastQuestionDetected) {
+                        this.logger.debug(`[QuestionDetector:${this.projectName}] Question modal disappeared`);
+                        this.lastQuestionDetected = false;
+                        this.emit('resolved');
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (e.message?.includes('Target closed') || e.message?.includes('Session closed')) {
+                // Ignore disconnect errors
+            }
+            else {
+                this.logger.error(`[QuestionDetector:${this.projectName}] Error:`, e.message);
+            }
+        }
+    }
+}
+exports.QuestionDetector = QuestionDetector;