lazy-gravity 0.9.2 → 0.11.0

package/dist/services/questionDetector.js

@@ -0,0 +1,428 @@
+"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 getInteractiveItems = (elContainer) => {
+                        return Array.from(elContainer.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                            .filter(el => {
+                                if (el.tagName === 'BUTTON' || el.closest('button')) return false;
+                                const role = el.getAttribute('role');
+                                if (['radio', 'option', 'checkbox', 'button', 'menuitem'].includes(role)) return true;
+                                if (el.tagName === 'A' || el.tagName === 'LABEL') return true;
+                                const style = window.getComputedStyle(el);
+                                return style.cursor === 'pointer';
+                            });
+                    };
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let targetList = null;
+                    let submitBtn = null;
+                    
+                    for (const container of containers) {
+                        const hasTextInput = container.querySelector('textarea, input:not([type="hidden"]):not([type="radio"]):not([type="checkbox"]), [contenteditable], [role="textbox"], .monaco-editor, .editor-container, .inputarea, vscode-text-field, vscode-text-area');
+                        const hasExplicitQuestionItems = container.querySelector('[role="radio"], input[type="radio"], input[type="checkbox"], [role="option"], [role="checkbox"]');
+                        if (hasTextInput && !hasExplicitQuestionItems) continue;
+                        const buttons = Array.from(container.querySelectorAll('button'));
+                        let possibleSubmitBtn = null;
+                        for (const btn of buttons) {
+                            const text = btn.textContent?.toLowerCase() || '';
+                            if (text.includes('submit') || text.includes('continue')) {
+                                possibleSubmitBtn = btn;
+                                break;
+                            }
+                        }
+                        
+                        if (possibleSubmitBtn) {
+                            const items = getInteractiveItems(container);
+                            
+                            if (items.length > 1) {
+                                targetList = container;
+                                submitBtn = possibleSubmitBtn;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!targetList || !submitBtn) return { found: false };
+
+                    const items = getInteractiveItems(targetList);
+                    if (items.length <= ${index}) return { found: false };
+                    
+                    const targetOption = items[${index}];
+                    
+                    const clickElement = (el) => {
+                        const rect = el.getBoundingClientRect();
+                        const clickX = rect.left + rect.width / 2;
+                        const clickY = rect.top + rect.height / 2;
+                        const events = ['pointerdown', 'mousedown', 'mouseup', 'click'];
+                        for (const type of events) {
+                            el.dispatchEvent(new MouseEvent(type, {
+                                bubbles: true,
+                                cancelable: true,
+                                view: window,
+                                clientX: clickX,
+                                clientY: clickY,
+                            }));
+                        }
+                    };
+                    
+                    return new Promise(resolve => {
+                        clickElement(targetOption);
+                        setTimeout(() => {
+                            clickElement(submitBtn);
+                            resolve({ found: true });
+                        }, 50);
+                    });
+                })()
+                `,
+                returnByValue: true,
+                awaitPromise: true,
+            };
+            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;
+            }
+            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 getInteractiveItems = (elContainer) => {
+                        return Array.from(elContainer.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                            .filter(el => {
+                                if (el.tagName === 'BUTTON' || el.closest('button')) return false;
+                                const role = el.getAttribute('role');
+                                if (['radio', 'option', 'checkbox', 'button', 'menuitem'].includes(role)) return true;
+                                if (el.tagName === 'A' || el.tagName === 'LABEL') return true;
+                                const style = window.getComputedStyle(el);
+                                return style.cursor === 'pointer';
+                            });
+                    };
+
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let skipBtn = null;
+                    
+                    for (const container of containers) {
+                        const hasTextInput = container.querySelector('textarea, input:not([type="hidden"]):not([type="radio"]):not([type="checkbox"]), [contenteditable="true"], [contenteditable=""], [role="textbox"]');
+                        const hasExplicitQuestionItems = container.querySelector('[role="radio"], input[type="radio"], input[type="checkbox"], [role="option"], [role="checkbox"]');
+                        if (hasTextInput && !hasExplicitQuestionItems) continue;
+                        const items = getInteractiveItems(container);
+                        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 clickElement = (el) => {
+                        const rect = el.getBoundingClientRect();
+                        const clickX = rect.left + rect.width / 2;
+                        const clickY = rect.top + rect.height / 2;
+                        const events = ['pointerdown', 'mousedown', 'mouseup', 'click'];
+                        for (const type of events) {
+                            el.dispatchEvent(new MouseEvent(type, {
+                                bubbles: true,
+                                cancelable: true,
+                                view: window,
+                                clientX: clickX,
+                                clientY: clickY,
+                            }));
+                        }
+                    };
+                    
+                    clickElement(skipBtn);
+                    return { found: true };
+                })()
+                `,
+                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;
+            }
+            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 STOP_PATTERNS = [
+                        /^stop$/,
+                        /^stop generating$/,
+                        /^stop response$/,
+                        /^停止$/,
+                        /^生成を停止$/,
+                        /^応答を停止$/,
+                    ];
+                    const normalize = (value) => (value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+                    const isStopLabel = (value) => {
+                        const normalized = normalize(value);
+                        if (!normalized) return false;
+                        return STOP_PATTERNS.some((re) => re.test(normalized));
+                    };
+                    const isGenerating = Array.from(document.querySelectorAll('button, [role="button"]')).some(btn => {
+                        const labels = [
+                            btn.textContent || '',
+                            btn.getAttribute('aria-label') || '',
+                            btn.getAttribute('title') || '',
+                        ];
+                        return labels.some(isStopLabel);
+                    }) || (() => {
+                        const panel = document.querySelector('.antigravity-agent-side-panel');
+                        if (panel) {
+                            const panelText = (panel.textContent || '').trim();
+                            return /Working\.\s*$/i.test(panelText);
+                        }
+                        return false;
+                    })();
+                    if (isGenerating) {
+                        return { detected: false, reason: "IDE is generating" };
+                    }
+
+                    const getInteractiveItems = (elContainer) => {
+                        return Array.from(elContainer.querySelectorAll('li, label, a, [role="radio"], [role="option"], [class*="cursor-pointer"]'))
+                            .filter(el => {
+                                if (el.tagName === 'BUTTON' || el.closest('button')) return false;
+                                const text = (el.innerText || el.textContent || '').trim();
+                                if (!text) return false;
+                                const role = el.getAttribute('role');
+                                if (['radio', 'option', 'checkbox', 'button', 'menuitem'].includes(role)) return true;
+                                if (el.tagName === 'A' || el.tagName === 'LABEL') return true;
+                                const style = window.getComputedStyle(el);
+                                return style.cursor === 'pointer';
+                            });
+                    };
+
+                    const containers = Array.from(document.querySelectorAll('div, form, dialog')).reverse();
+                    let targetList = null;
+                    let submitBtn = null;
+                    
+                    for (const container of containers) {
+                        const hasTextInput = container.querySelector('textarea, input:not([type="hidden"]):not([type="radio"]):not([type="checkbox"]), [contenteditable], [role="textbox"], .monaco-editor, .editor-container, .inputarea, vscode-text-field, vscode-text-area');
+                        const hasExplicitQuestionItems = container.querySelector('[role="radio"], input[type="radio"], input[type="checkbox"], [role="option"], [role="checkbox"]');
+                        if (hasTextInput && !hasExplicitQuestionItems) continue;
+                        const buttons = Array.from(container.querySelectorAll('button'));
+                        let possibleSubmitBtn = null;
+                        for (const btn of buttons) {
+                            const text = btn.textContent?.toLowerCase() || '';
+                            if (text.includes('submit') || text.includes('continue')) {
+                                possibleSubmitBtn = btn;
+                                break;
+                            }
+                        }
+                        
+                        if (possibleSubmitBtn) {
+                            const items = getInteractiveItems(container);
+                            
+                            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 = getInteractiveItems(targetList);
+                    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 (!this._isStarted)
+                    return;
+                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;
+                }
+            }
+            if (!this._isStarted)
+                return;
+            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;

package/dist/services/responseMonitor.js

@@ -146,6 +146,13 @@ exports.RESPONSE_SELECTORS = {
             }
         }
 
+        if (panel) {
+            const panelText = (panel.textContent || '').trim();
+            if (/Working\.\s*$/i.test(panelText)) {
+                return { isGenerating: true };
+            }
+        }
+
         return { isGenerating: false };
     })()`,
     /** Click stop button via tooltip-id + text fallback */
@@ -601,6 +608,8 @@ class ResponseMonitor {
     extractionMode;
     onProgress;
     onComplete;
+    onStructuredProgress;
+    onStructuredComplete;
     onTimeout;
     onPhaseChange;
     onProcessLog;
@@ -609,12 +618,15 @@ class ResponseMonitor {
     pollTimer = null;
     isRunning = false;
     lastText = null;
+    lastClassified = null;
     baselineText = null;
     generationStarted = false;
     currentPhase = 'waiting';
     stopGoneCount = 0;
     quotaDetected = false;
     seenProcessLogKeys = new Set();
+    currentCitedFiles = [];
+    currentFileChanges = [];
     structuredDiagLogged = false;
     lastContentContextId = null;
     // CDP disconnect handling (#48)
@@ -624,6 +636,7 @@ class ResponseMonitor {
     onCdpReconnectFailed = null;
     // Activity-based timeout (#49)
     lastActivityTime = 0;
+    startTime = 0;
     constructor(options) {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
@@ -632,12 +645,17 @@ class ResponseMonitor {
         this.extractionMode = options.extractionMode ?? 'structured';
         this.onProgress = options.onProgress;
         this.onComplete = options.onComplete;
+        this.onStructuredProgress = options.onStructuredProgress;
+        this.onStructuredComplete = options.onStructuredComplete;
         this.onTimeout = options.onTimeout;
         this.onPhaseChange = options.onPhaseChange;
         this.onProcessLog = options.onProcessLog;
         this.initialBaselineText = options.initialBaselineText;
         this.initialSeenProcessLogKeys = options.initialSeenProcessLogKeys;
     }
+    getLastClassified() {
+        return this.lastClassified;
+    }
     /** Start monitoring */
     async start() {
         return this.initMonitoring(false);
@@ -721,6 +739,7 @@ class ResponseMonitor {
         }
         // Activity-based timeout: track last activity time instead of fixed timer (#49)
         this.lastActivityTime = Date.now();
+        this.startTime = Date.now();
         // Register CDP connection event listeners (#48)
         this.registerCdpConnectionListeners();
         const mode = passive ? 'Passive monitoring' : 'Monitoring';
@@ -979,6 +998,7 @@ class ResponseMonitor {
                     if (classified.diagnostics.source === 'dom-structured') {
                         currentText = classified.finalOutputText.trim() || null;
                         structuredHandledLogs = true;
+                        this.lastClassified = classified;
                         if (!this.structuredDiagLogged) {
                             this.structuredDiagLogged = true;
                             logger_1.logger.debug('[ResponseMonitor] Structured extraction OK — segments:', classified.diagnostics.segmentCounts);
@@ -987,6 +1007,8 @@ class ResponseMonitor {
                         if (classified.activityLines.length > 0) {
                             this.emitNewProcessLogs(classified.activityLines);
                         }
+                        this.currentCitedFiles = classified.citedFiles || [];
+                        this.currentFileChanges = classified.fileChangesTexts || [];
                     }
                     else if (!this.structuredDiagLogged) {
                         this.structuredDiagLogged = true;
@@ -1037,6 +1059,8 @@ class ResponseMonitor {
                     await this.stop();
                     try {
                         await Promise.resolve(this.onComplete?.(''));
+                        if (this.lastClassified)
+                            await Promise.resolve(this.onStructuredComplete?.(this.lastClassified));
                     }
                     catch (error) {
                         logger_1.logger.error('[ResponseMonitor] complete callback failed:', error);
@@ -1061,7 +1085,16 @@ class ResponseMonitor {
                         this.generationStarted = true;
                     }
                 }
-                this.onProgress?.(effectiveText);
+                this.onProgress?.(effectiveText || '');
+                if (this.lastClassified)
+                    this.onStructuredProgress?.(this.lastClassified);
+            }
+            else if (this.lastClassified && this.extractionMode === 'structured') {
+                // If text didn't change but structured data did (e.g. new file changes), emit structured progress anyway
+                // To keep it simple, we just emit on structured mode if generation is active.
+                if (isGenerating && this.generationStarted) {
+                    this.onStructuredProgress?.(this.lastClassified);
+                }
             }
             // Completion: stop button gone N consecutive times
             if (!isGenerating && this.generationStarted) {
@@ -1071,7 +1104,9 @@ class ResponseMonitor {
                     this.setPhase('complete', finalText);
                     await this.stop();
                     try {
-                        await Promise.resolve(this.onComplete?.(finalText));
+                        await Promise.resolve(this.onComplete?.(finalText, this.currentCitedFiles, this.currentFileChanges));
+                        if (this.lastClassified)
+                            await Promise.resolve(this.onStructuredComplete?.(this.lastClassified));
                     }
                     catch (error) {
                         logger_1.logger.error('[ResponseMonitor] complete callback failed:', error);
@@ -1083,7 +1118,14 @@ class ResponseMonitor {
             // Guard: never timeout while the stop button is visible — it means
             // Antigravity is still actively generating (extended thinking, long
             // shell commands, large file operations, etc.).
-            if (this.maxDurationMs > 0 && !isGenerating && Date.now() - this.lastActivityTime >= this.maxDurationMs) {
+            // Hard timeout limit (20 minutes absolute hard timeout)
+            const hardTimeoutLimit = 1200000;
+            const totalElapsed = Date.now() - this.startTime;
+            const isHardTimeout = totalElapsed >= hardTimeoutLimit;
+            if (isHardTimeout || (this.maxDurationMs > 0 && !isGenerating && Date.now() - this.lastActivityTime >= this.maxDurationMs)) {
+                if (isHardTimeout) {
+                    logger_1.logger.warn(`[ResponseMonitor] Hard timeout of 20 minutes reached.`);
+                }
                 const lastText = this.lastText ?? '';
                 this.setPhase('timeout', lastText);
                 await this.stop();

package/dist/services/runCommandDetector.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunCommandDetector = void 0;
+const consecutiveEmptyPollGate_1 = require("../utils/consecutiveEmptyPollGate");
 const logger_1 = require("../utils/logger");
 const approvalDetector_1 = require("./approvalDetector");
 /**
@@ -25,7 +26,7 @@ const approvalDetector_1 = require("./approvalDetector");
  */
 const DETECT_RUN_COMMAND_SCRIPT = `(() => {
     const RUN_COMMAND_HEADER_PATTERNS = [
-        'run command?', 'run command', 'execute command',
+        'run command?', 'run command', 'execute command', 'command execution',
         'コマンドを実行', 'コマンド実行'
     ];
     const RUN_PATTERNS = ['run', 'accept', '実行', 'execute'];
@@ -111,8 +112,10 @@ class RunCommandDetector {
     isRunning = false;
     /** Key of the last detected dialog (for duplicate notification prevention) */
     lastDetectedKey = null;
-    /** Full RunCommandInfo from the last detection (used for clicking) */
+    /** Full RunCommandInfo from the last detection */
     lastDetectedInfo = null;
+    /** Gate for empty polls before reset */
+    emptyPollGate = new consecutiveEmptyPollGate_1.ConsecutiveEmptyPollGate(3);
     constructor(options) {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 1500;
@@ -126,6 +129,7 @@ class RunCommandDetector {
         this.isRunning = true;
         this.lastDetectedKey = null;
         this.lastDetectedInfo = null;
+        this.emptyPollGate.reset();
         this.schedulePoll();
     }
     /** Stop monitoring. */
@@ -171,6 +175,7 @@ class RunCommandDetector {
             const result = await this.cdpService.call('Runtime.evaluate', callParams);
             const info = result?.result?.value ?? null;
             if (info) {
+                this.emptyPollGate.recordDetection();
                 // Duplicate prevention: use commandText as key
                 const key = `${info.commandText}::${info.workingDirectory}`;
                 if (key !== this.lastDetectedKey) {
@@ -180,11 +185,13 @@ class RunCommandDetector {
                 }
             }
             else {
-                const wasDetected = this.lastDetectedKey !== null;
-                this.lastDetectedKey = null;
-                this.lastDetectedInfo = null;
-                if (wasDetected && this.onResolved) {
-                    this.onResolved();
+                if (this.emptyPollGate.recordEmptyPoll()) {
+                    const wasDetected = this.lastDetectedKey !== null;
+                    this.lastDetectedKey = null;
+                    this.lastDetectedInfo = null;
+                    if (wasDetected && this.onResolved) {
+                        this.onResolved();
+                    }
                 }
             }
         }

package/dist/ui/artifactsUi.js

@@ -11,6 +11,7 @@ exports.sendArtifactsUI = sendArtifactsUI;
 exports.sendArtifactPickerUI = sendArtifactPickerUI;
 const discord_js_1 = require("discord.js");
 const artifactService_1 = require("../services/artifactService");
+const pathUtils_1 = require("../utils/pathUtils");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -143,7 +144,8 @@ async function sendArtifactPickerUI(interaction, deps, edit = false, resolvedCon
             // Fallback to title matching if ID is not in DB or doesn't match a real folder
             if (!conversationId || !artifactService.listArtifacts(conversationId).length) {
                 const sessionTitle = session.displayName?.trim() ?? '';
-                const matchedId = sessionTitle ? artifactService.findConversationByTitle(sessionTitle) : null;
+                const workspaceDirName = (0, pathUtils_1.getWorkspaceDirName)(session);
+                const matchedId = sessionTitle ? artifactService.findConversationByTitle(sessionTitle, workspaceDirName) : null;
                 if (matchedId)
                     conversationId = matchedId;
             }
@@ -151,8 +153,7 @@ async function sendArtifactPickerUI(interaction, deps, edit = false, resolvedCon
             // to avoid showing artifacts from other projects/chats.
         }
         else {
-            // Final fallback: latest overall (only for non-session channels)
-            conversationId = artifactService.getLatestConversationWithArtifacts();
+            conversationId = null;
         }
     }
     if (!conversationId) {