lazy-gravity 0.9.1 → 0.10.0

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;

package/dist/services/responseMonitor.js

@@ -601,6 +601,8 @@ class ResponseMonitor {
     extractionMode;
     onProgress;
     onComplete;
+    onStructuredProgress;
+    onStructuredComplete;
     onTimeout;
     onPhaseChange;
     onProcessLog;
@@ -609,12 +611,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)
@@ -632,12 +637,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);
@@ -979,6 +989,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 +998,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 +1050,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 +1076,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 +1095,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);

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) {

package/dist/utils/consecutiveEmptyPollGate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsecutiveEmptyPollGate = void 0;
+class ConsecutiveEmptyPollGate {
+    requiredEmptyPolls;
+    count = 0;
+    constructor(requiredEmptyPolls = 3) {
+        this.requiredEmptyPolls = requiredEmptyPolls;
+    }
+    recordDetection() {
+        this.count = 0;
+    }
+    recordEmptyPoll() {
+        this.count++;
+        return this.count >= this.requiredEmptyPolls;
+    }
+    reset() {
+        this.count = 0;
+    }
+}
+exports.ConsecutiveEmptyPollGate = ConsecutiveEmptyPollGate;

package/dist/utils/fileOpenCache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileOpenCache = void 0;
+/**
+ * In-memory cache to map button customIds to file URLs.
+ * Bounded to a maximum size to prevent memory leaks, and entries are removed once consumed.
+ */
+class BoundedCache {
+    max_size;
+    map;
+    constructor(max_size = 1000) {
+        this.max_size = max_size;
+        this.map = new Map();
+    }
+    set(key, value) {
+        if (this.map.size >= this.max_size) {
+            // Remove the oldest entry (first item in the map's insertion order)
+            const firstKey = this.map.keys().next().value;
+            if (firstKey !== undefined) {
+                this.map.delete(firstKey);
+            }
+        }
+        this.map.set(key, value);
+    }
+    get(key) {
+        const value = this.map.get(key);
+        if (value !== undefined) {
+            this.map.delete(key); // Remove upon consumption
+        }
+        return value;
+    }
+}
+exports.fileOpenCache = new BoundedCache(1000);

package/dist/utils/htmlToDiscordMarkdown.js

@@ -42,6 +42,9 @@ function htmlToDiscordMarkdown(html) {
     // Extract language from class="language-xxx" if present.
     // Do NOT decode entities here — let the final decodeEntities() handle them
     // after stripTags() has run, to avoid decoded < > being stripped as tags.
+    // First, Antigravity 2.0 wrapped code blocks
+    result = result.replace(/<div[^>]*class="[^"]*code-block[^"]*"[^>]*>(?:(?!<div[^>]*class="[^"]*code-block[^"]*"[^>]*>)[\s\S])*?<div[^>]*class="[^"]*code-header[^"]*"[^>]*>([\s\S]*?)<\/div>(?:(?!<div[^>]*class="[^"]*code-block[^"]*"[^>]*>)[\s\S])*?<pre[^>]*>\s*<code[^>]*>([\s\S]*?)<\/code>\s*<\/pre>(?:(?!<div[^>]*class="[^"]*code-block[^"]*"[^>]*>)[\s\S])*?<\/div>/gi, (_m, lang, content) => `\n\`\`\`${stripTags(lang).trim()}\n${content}\n\`\`\`\n`);
+    // Standard <pre><code> blocks
     result = result.replace(/<pre[^>]*>\s*<code(?:\s+class="language-([^"]*)")?[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/gi, (_m, lang, content) => `\n\`\`\`${lang || ''}\n${content}\n\`\`\`\n`);
     // Handle inline <code>
     result = result.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
@@ -49,8 +52,8 @@ function htmlToDiscordMarkdown(html) {
     result = result.replace(/<(?:strong|b)(?:\s[^>]*)?>((?: |\s|[^<]|<(?!\/(?:strong|b)>))*)<\/(?:strong|b)>/gi, '**$1**');
     // Handle <em> and <i>
     result = result.replace(/<(?:em|i)(?:\s[^>]*)?>((?: |\s|[^<]|<(?!\/(?:em|i)>))*)<\/(?:em|i)>/gi, '*$1*');
-    // Handle <span class="context-scope-mention"> → `text`
-    result = result.replace(/<span[^>]*class="[^"]*context-scope-mention[^"]*"[^>]*>([\s\S]*?)<\/span>/gi, (_m, text) => `\`${stripTags(text).trim()}\``);
+    // Handle <span class="context-scope-mention"> or <span class="file-chip"> → `text`
+    result = result.replace(/<span[^>]*class="[^"]*(?:context-scope-mention|file-chip)[^"]*"[^>]*>([\s\S]*?)<\/span>/gi, (_m, text) => `\`${stripTags(text).trim()}\``);
     // Handle elements with title attribute containing file paths
     // e.g. <div title="src/bot/index.ts">:54</div> → src/bot/index.ts:54
     result = result.replace(/<(?:div|span|a)[^>]*\btitle="([^"]*)"[^>]*>([\s\S]*?)<\/(?:div|span|a)>/gi, (_m, title, text) => {

package/dist/utils/pathUtils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAntigravityCliPath = getAntigravityCliPath;
 exports.extractProjectNameFromPath = extractProjectNameFromPath;
 exports.getAntigravityCdpHint = getAntigravityCdpHint;
+exports.getWorkspaceDirName = getWorkspaceDirName;
 /**
  * Helper to resolve the correct Antigravity CLI executable path based on the operating system
  * and environment variables.
@@ -55,3 +56,14 @@ function getAntigravityCdpHint(port = 9222) {
             return `${APP_NAME.toLowerCase()} --remote-debugging-port=${port}`;
     }
 }
+/**
+ * Extracts the workspace directory name from a chat session.
+ * @param session The chat session object
+ * @returns The base directory name, or undefined
+ */
+function getWorkspaceDirName(session) {
+    if (session && session.workspacePath) {
+        return extractProjectNameFromPath(session.workspacePath);
+    }
+    return undefined;
+}

package/dist/utils/projectResolver.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectName = resolveProjectName;
+function resolveProjectName(deps, channelId, providedProjectName) {
+    if (providedProjectName) {
+        return providedProjectName;
+    }
+    const workspacePath = deps.wsHandler.getWorkspaceForChannel(channelId);
+    return workspacePath ? deps.bridge.pool.extractProjectName(workspacePath) : undefined;
+}