lazy-gravity 0.9.2 → 0.11.0

package/dist/bot/index.js

@@ -46,6 +46,9 @@ const logger_1 = require("../utils/logger");
 const logBuffer_1 = require("../utils/logBuffer");
 const discord_js_1 = require("discord.js");
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
 const wrappers_1 = require("../platform/discord/wrappers");
 const config_1 = require("../utils/config");
 const slashCommandHandler_1 = require("../commands/slashCommandHandler");
@@ -72,10 +75,12 @@ const chatSessionService_1 = require("../services/chatSessionService");
 const responseMonitor_1 = require("../services/responseMonitor");
 const antigravityLauncher_1 = require("../services/antigravityLauncher");
 const pathUtils_1 = require("../utils/pathUtils");
+const fileOpenCache_1 = require("../utils/fileOpenCache");
 const promptDispatcher_1 = require("../services/promptDispatcher");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const streamMessageFormatter_1 = require("../utils/streamMessageFormatter");
 const discordFormatter_1 = require("../utils/discordFormatter");
+const discordResponseRenderer_1 = require("../platform/discord/discordResponseRenderer");
 const processLogBuffer_1 = require("../utils/processLogBuffer");
 const imageHandler_1 = require("../utils/imageHandler");
 const modeUi_1 = require("../ui/modeUi");
@@ -106,8 +111,11 @@ const planningButtonAction_1 = require("../handlers/planningButtonAction");
 const errorPopupButtonAction_1 = require("../handlers/errorPopupButtonAction");
 const runCommandButtonAction_1 = require("../handlers/runCommandButtonAction");
 const modelButtonAction_1 = require("../handlers/modelButtonAction");
-const autoAcceptButtonAction_1 = require("../handlers/autoAcceptButtonAction");
+const questionSelectAction_1 = require("../handlers/questionSelectAction");
 const templateButtonAction_1 = require("../handlers/templateButtonAction");
+const fileChangeButtonAction_1 = require("../handlers/fileChangeButtonAction");
+const autoAcceptButtonAction_1 = require("../handlers/autoAcceptButtonAction");
+const genericActionButtonAction_1 = require("../handlers/genericActionButtonAction");
 const modeSelectAction_1 = require("../handlers/modeSelectAction");
 const accountSelectAction_1 = require("../handlers/accountSelectAction");
 const telegramStartupTarget_1 = require("./telegramStartupTarget");
@@ -172,8 +180,9 @@ function createSerialTaskQueueForTest(queueName, traceId) {
         return queue;
     };
 }
+// Shared fileOpenCache is imported from utils/fileOpenCache
 /**
- * Send a Discord message (prompt) to Antigravity, wait for the response, and relay it back to Discord
+ * Send a user's prompt to Antigravity and monitor generation.
  *
  * Message strategy:
  *   - Send new messages per phase instead of editing, to preserve history
@@ -182,11 +191,15 @@ function createSerialTaskQueueForTest(queueName, traceId) {
 async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService, modelService, inboundImages = [], options) {
     // Completion signal — called exactly once when the entire prompt lifecycle ends
     let completionSignaled = false;
+    let onApprovalRef = null;
     const signalCompletion = (exitPath) => {
         if (completionSignaled)
             return;
         completionSignaled = true;
         logger_1.logger.debug(`[sendPrompt:${message.channelId}] signalCompletion via ${exitPath}`);
+        if (onApprovalRef) {
+            cdp.off('approval_required', onApprovalRef);
+        }
         options?.onFullCompletion?.();
     };
     // Resolve output format once at the start (no mid-response switches)
@@ -408,16 +421,20 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 return;
             lastLiveResponseKey = renderKey;
             for (let i = 0; i < plainChunks.length; i++) {
+                const messageOpts = { content: plainChunks[i] };
+                if (i === plainChunks.length - 1 && opts?.components?.length) {
+                    messageOpts.components = opts.components;
+                }
                 if (!liveResponseMessages[i]) {
-                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch((error) => {
+                    liveResponseMessages[i] = await channel.send(messageOpts).catch((error) => {
                         logDeliveryError('liveResponse/plain/send', error);
                         return null;
                     });
                     continue;
                 }
-                await liveResponseMessages[i].edit({ content: plainChunks[i] }).catch(async (error) => {
+                await liveResponseMessages[i].edit(messageOpts).catch(async (error) => {
                     logDeliveryError('liveResponse/plain/edit', error);
-                    liveResponseMessages[i] = await channel.send({ content: plainChunks[i] }).catch((sendError) => {
+                    liveResponseMessages[i] = await channel.send(messageOpts).catch((sendError) => {
                         logDeliveryError('liveResponse/plain/resend', sendError);
                         return null;
                     });
@@ -445,15 +462,23 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 .setFooter({ text: footerText })
                 .setTimestamp();
             if (!liveResponseMessages[i]) {
-                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch((error) => {
+                const messageOpts = { embeds: [embed] };
+                if (i === descriptions.length - 1 && opts?.components?.length) {
+                    messageOpts.components = opts.components;
+                }
+                liveResponseMessages[i] = await channel.send(messageOpts).catch((error) => {
                     logDeliveryError('liveResponse/embed/send', error);
                     return null;
                 });
                 continue;
             }
-            await liveResponseMessages[i].edit({ embeds: [embed] }).catch(async (error) => {
+            const messageOpts = { embeds: [embed] };
+            if (i === descriptions.length - 1 && opts?.components?.length) {
+                messageOpts.components = opts.components;
+            }
+            await liveResponseMessages[i].edit(messageOpts).catch(async (error) => {
                 logDeliveryError('liveResponse/embed/edit', error);
-                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch((sendError) => {
+                liveResponseMessages[i] = await channel.send(messageOpts).catch((sendError) => {
                     logDeliveryError('liveResponse/embed/resend', sendError);
                     return null;
                 });
@@ -544,16 +569,18 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
     try {
         const baseline = await (0, responseMonitor_1.captureResponseMonitorBaseline)(cdp);
         logger_1.logger.prompt(prompt);
-        let injectResult;
-        if (inboundImages.length > 0) {
-            injectResult = await cdp.injectMessageWithImageFiles(prompt, inboundImages.map((image) => image.localPath));
-            if (!injectResult.ok) {
-                await sendEmbed((0, i18n_1.t)('🖼️ Attached image fallback'), (0, i18n_1.t)('Failed to attach image directly, resending via URL reference.'), PHASE_COLORS.thinking);
-                injectResult = await cdp.injectMessage((0, imageHandler_1.buildPromptWithAttachmentUrls)(prompt, inboundImages));
+        let injectResult = { ok: true };
+        if (!options?.resumeOnly) {
+            if (inboundImages.length > 0) {
+                injectResult = await cdp.injectMessageWithImageFiles(prompt, inboundImages.map((image) => image.localPath));
+                if (!injectResult.ok) {
+                    await sendEmbed((0, i18n_1.t)('🖼️ Attached image fallback'), (0, i18n_1.t)('Failed to attach image directly, resending via URL reference.'), PHASE_COLORS.thinking);
+                    injectResult = await cdp.injectMessage((0, imageHandler_1.buildPromptWithAttachmentUrls)(prompt, inboundImages));
+                }
+            }
+            else {
+                injectResult = await cdp.injectMessage(prompt);
             }
-        }
-        else {
-            injectResult = await cdp.injectMessage(prompt);
         }
         if (!injectResult.ok) {
             isFinalized = true;
@@ -564,6 +591,8 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             return;
         }
         const startTime = Date.now();
+        let earlyConvIdResolved = false;
+        let earlyConvIdInFlight = false;
         await upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, '', PHASE_COLORS.thinking, (0, i18n_1.t)('⏱️ Elapsed: 0s | Process log'), { source: 'initial' });
         const monitor = new responseMonitor_1.ResponseMonitor({
             cdpService: cdp,
@@ -590,6 +619,30 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                     expectedVersion: activityVersion,
                     skipWhenFinalized: true,
                 }).catch(() => { });
+                // Try to resolve conversation_id early if not already bound
+                const { artifactService, chatSessionRepo, chatSessionService } = options || {};
+                if (!earlyConvIdResolved && !earlyConvIdInFlight && artifactService && chatSessionRepo && chatSessionService) {
+                    earlyConvIdInFlight = true;
+                    chatSessionService.getCurrentSessionInfo(cdp)
+                        .then((sessionInfo) => {
+                        if (sessionInfo && sessionInfo.title && sessionInfo.title !== (0, i18n_1.t)('(Untitled)')) {
+                            const session = chatSessionRepo.findByChannelId(message.channelId);
+                            const workspaceDirName = (session
+                                ? bridge.pool.extractProjectName(session.workspacePath)
+                                : cdp.getCurrentWorkspaceName()) ?? undefined;
+                            const convId = artifactService.findConversationByTitle(sessionInfo.title, workspaceDirName);
+                            if (convId) {
+                                chatSessionRepo.setConversationId(message.channelId, convId);
+                                earlyConvIdResolved = true;
+                                logger_1.logger.debug(`[EarlyBinding] Saved conversation_id: "${convId}" for channel: ${message.channelId}`);
+                            }
+                        }
+                    })
+                        .catch(() => { })
+                        .finally(() => {
+                        earlyConvIdInFlight = false;
+                    });
+                }
             },
             onProgress: (text) => {
                 if (isFinalized)
@@ -600,7 +653,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                     lastProgressText = separated.output;
                 }
             },
-            onComplete: async (finalText) => {
+            onComplete: async (finalText, citedFiles, fileChanges) => {
                 isFinalized = true;
                 try {
                     // If the user explicitly pressed /stop, skip output display entirely
@@ -680,18 +733,15 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                         });
                         liveResponseUpdateVersion += 1;
                         const responseVersion = liveResponseUpdateVersion;
-                        if (finalOutputText && finalOutputText.trim().length > 0) {
-                            await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Final Output`, finalOutputText, PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
-                                source: 'complete',
-                                expectedVersion: responseVersion,
-                            });
-                        }
-                        else {
-                            await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use `/screenshot` to verify.'), PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
-                                source: 'complete',
-                                expectedVersion: responseVersion,
-                            });
+                        const components = [];
+                        if (!citedFiles)
+                            citedFiles = [];
+                        // Only pause when newly created conversation folders and files need to flush to disk
+                        const existingConvId = options?.chatSessionRepo?.findByChannelId(message.channelId)?.conversationId;
+                        if (!existingConvId) {
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
                         }
+                        let activeConversationId = undefined;
                         if (options && message.guild) {
                             try {
                                 const sessionInfo = await options.chatSessionService.getCurrentSessionInfo(cdp);
@@ -711,9 +761,15 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                     }
                                     // Persist conversation_id for artifact picker resolution
                                     if (options.artifactService) {
-                                        const convId = options.artifactService.findConversationByTitle(sessionInfo.title);
+                                        const session = options.chatSessionRepo.findByChannelId(message.channelId);
+                                        let workspaceDirName;
+                                        if (session && session.workspacePath) {
+                                            workspaceDirName = bridge.pool.extractProjectName(session.workspacePath);
+                                        }
+                                        const convId = options.artifactService.findConversationByTitle(sessionInfo.title, workspaceDirName);
                                         if (convId) {
                                             options.chatSessionRepo.setConversationId(message.channelId, convId);
+                                            activeConversationId = convId;
                                         }
                                     }
                                 }
@@ -722,6 +778,201 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                 logger_1.logger.error('[Rename] Failed to get title from Antigravity and rename:', e);
                             }
                         }
+                        const classifiedForFiles = monitor.getLastClassified();
+                        if (classifiedForFiles?.fileChanges && classifiedForFiles.fileChanges.length > 0) {
+                            for (const fc of classifiedForFiles.fileChanges) {
+                                if (!citedFiles.includes(fc.path)) {
+                                    citedFiles.push(fc.path);
+                                }
+                            }
+                        }
+                        if (!activeConversationId && options?.chatSessionRepo) {
+                            activeConversationId = options.chatSessionRepo.findByChannelId(message.channelId)?.conversationId ?? undefined;
+                        }
+                        if (activeConversationId && options?.artifactService) {
+                            const artifacts = options.artifactService.listArtifacts(activeConversationId);
+                            const planArt = artifacts.find(art => art.artifactType === 'ARTIFACT_TYPE_IMPLEMENTATION_PLAN' ||
+                                art.filename.toLowerCase() === 'implementation_plan.md');
+                            let planTime = 0;
+                            if (planArt) {
+                                try {
+                                    planTime = fs_1.default.statSync(planArt.absolutePath).mtimeMs;
+                                }
+                                catch { /* ignore */ }
+                            }
+                            for (const art of artifacts) {
+                                const nameWithExt = art.filename;
+                                const nameWithoutExt = art.filename.replace(/\.[^/.]+$/, "");
+                                const regex = new RegExp(`\\b${nameWithoutExt.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\b`, 'i');
+                                const mentionsArtifact = finalOutputText.includes(nameWithExt) || finalOutputText.includes(`\`${nameWithoutExt}\``) || regex.test(finalOutputText);
+                                const isTask = art.artifactType === 'ARTIFACT_TYPE_TASK' || nameWithExt.toLowerCase() === 'task.md';
+                                const isWalkthrough = art.artifactType === 'ARTIFACT_TYPE_WALKTHROUGH' || nameWithExt.toLowerCase() === 'walkthrough.md';
+                                let isSpecialArtifact = false;
+                                if (isTask || isWalkthrough) {
+                                    let artTime = 0;
+                                    try {
+                                        artTime = fs_1.default.statSync(art.absolutePath).mtimeMs;
+                                    }
+                                    catch { /* ignore */ }
+                                    if (artTime > planTime) {
+                                        isSpecialArtifact = true;
+                                    }
+                                }
+                                if ((mentionsArtifact || isSpecialArtifact) && !citedFiles.includes(nameWithExt)) {
+                                    citedFiles.push(nameWithExt);
+                                }
+                            }
+                        }
+                        if (citedFiles && citedFiles.length > 0) {
+                            // Strip trailing punctuation and deduplicate
+                            let uniqueFiles = Array.from(new Set(citedFiles.map(f => {
+                                let clean = f.trim();
+                                while (clean.match(/[.,;:!?]$/)) {
+                                    clean = clean.slice(0, -1);
+                                }
+                                return clean;
+                            })));
+                            // Filter out obviously bad paths
+                            uniqueFiles = uniqueFiles.filter(f => f.length > 0 && f !== 'unknown');
+                            const row = new discord_js_1.ActionRowBuilder();
+                            // Max 5 buttons per row in Discord
+                            for (let i = 0; i < Math.min(uniqueFiles.length, 5); i++) {
+                                let fileUrl = uniqueFiles[i];
+                                let isArtifactMatch = false;
+                                let artifactDisplayName = fileUrl;
+                                if (activeConversationId && options?.artifactService) {
+                                    const artifacts = options.artifactService.listArtifacts(activeConversationId);
+                                    const rawName = fileUrl.replace(/^file:\/\/\//, '');
+                                    const matched = artifacts.find(a => a.filename.toLowerCase() === fileUrl.toLowerCase() ||
+                                        a.filename.toLowerCase() === rawName.toLowerCase());
+                                    if (matched) {
+                                        isArtifactMatch = true;
+                                        fileUrl = `file:///${matched.absolutePath.replace(/\\/g, '/')}`;
+                                        artifactDisplayName = matched.filename;
+                                    }
+                                }
+                                const wsPath = cdp.getCurrentWorkspacePath();
+                                if (!wsPath) {
+                                    continue;
+                                }
+                                if (!isArtifactMatch) {
+                                    if (!fileUrl.startsWith('file:///') && !path_1.default.isAbsolute(fileUrl)) {
+                                        fileUrl = `file:///${path_1.default.resolve(wsPath, fileUrl).replace(/\\/g, '/')}`;
+                                    }
+                                    let fsPath = fileUrl.replace(/^file:\/\/\//, '');
+                                    if (path_1.default.sep === '/' && !fsPath.startsWith('/')) {
+                                        fsPath = '/' + fsPath;
+                                    }
+                                    else if (process.platform === 'win32' && fsPath.startsWith('/')) {
+                                        fsPath = fsPath.substring(1);
+                                    }
+                                    const relative = path_1.default.relative(wsPath, fsPath);
+                                    const isArtifact = fsPath.includes('.gemini') && fsPath.includes('antigravity') && fsPath.includes('brain');
+                                    if (!isArtifact && (relative.startsWith('..') || path_1.default.isAbsolute(relative))) {
+                                        continue;
+                                    }
+                                    if (!fs_1.default.existsSync(fsPath)) {
+                                        continue;
+                                    }
+                                }
+                                let displayName = fileUrl;
+                                if (isArtifactMatch) {
+                                    displayName = artifactDisplayName;
+                                }
+                                else if (displayName.startsWith('file:///')) {
+                                    const parts = displayName.split('/');
+                                    displayName = parts[parts.length - 1];
+                                }
+                                const hashId = Math.random().toString(36).substring(2, 10);
+                                fileOpenCache_1.fileOpenCache.set(hashId, fileUrl);
+                                let customId = `file_open:cache:${hashId}`;
+                                if (isArtifactMatch && activeConversationId && displayName) {
+                                    const artId = `file_open:art:${activeConversationId}:${displayName}`;
+                                    if (artId.length < 100) {
+                                        customId = artId;
+                                    }
+                                }
+                                else if (wsPath) {
+                                    let fsPath = fileUrl.replace(/^file:\/\/\//, '');
+                                    if (path_1.default.sep === '/' && !fsPath.startsWith('/')) {
+                                        fsPath = '/' + fsPath;
+                                    }
+                                    else if (process.platform === 'win32' && fsPath.startsWith('/')) {
+                                        fsPath = fsPath.substring(1);
+                                    }
+                                    const resolvedFsPath = path_1.default.resolve(fsPath);
+                                    const relative = path_1.default.relative(wsPath, resolvedFsPath);
+                                    if (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)) {
+                                        const relSlash = relative.replace(/\\/g, '/');
+                                        const relId = `file_open:rel:${relSlash}`;
+                                        if (relId.length < 100) {
+                                            customId = relId;
+                                        }
+                                    }
+                                }
+                                row.addComponents(new discord_js_1.ButtonBuilder()
+                                    .setCustomId(customId)
+                                    .setLabel(isArtifactMatch ? `Review ${displayName.substring(0, 15)}` : `Open ${displayName.substring(0, 20)}`)
+                                    .setStyle(isArtifactMatch ? discord_js_1.ButtonStyle.Success : discord_js_1.ButtonStyle.Primary));
+                            }
+                            if (row.components.length > 0) {
+                                components.push(row);
+                            }
+                        }
+                        if (fileChanges && fileChanges.length > 0) {
+                            // The extracted text is the toolbar title, e.g. "1 File With Changes"
+                            const widgetTitle = fileChanges[fileChanges.length - 1] || 'Files With Changes';
+                            const fileChangesRow = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+                                .setCustomId((0, cdpBridgeManager_1.buildFileChangeCustomId)('reject', cdp.getCurrentWorkspaceName() || 'unknown', message.channelId))
+                                .setLabel(`Reject all (${widgetTitle})`)
+                                .setStyle(discord_js_1.ButtonStyle.Danger), new discord_js_1.ButtonBuilder()
+                                .setCustomId((0, cdpBridgeManager_1.buildFileChangeCustomId)('accept', cdp.getCurrentWorkspaceName() || 'unknown', message.channelId))
+                                .setLabel('Accept all')
+                                .setStyle(discord_js_1.ButtonStyle.Success));
+                            components.push(fileChangesRow);
+                        }
+                        const classified = monitor.getLastClassified();
+                        if (options?.extractionMode === 'structured' && classified && outputFormat !== 'plain') {
+                            const messageOptions = (0, discordResponseRenderer_1.renderDiscordResponse)(classified, {
+                                projectName: cdp.getCurrentWorkspaceName() || 'unknown',
+                                channelId: message.channelId
+                            });
+                            for (const msg of liveResponseMessages) {
+                                if (msg)
+                                    await msg.delete().catch(() => { });
+                            }
+                            liveResponseMessages.length = 0;
+                            if (components.length > 0) {
+                                if (!messageOptions.components)
+                                    messageOptions.components = [];
+                                messageOptions.components = [...(messageOptions.components || []), ...components];
+                            }
+                            if (messageOptions.embeds && messageOptions.embeds.length > 0) {
+                                const lastEmbed = messageOptions.embeds[messageOptions.embeds.length - 1];
+                                if (lastEmbed && typeof lastEmbed.setFooter === 'function') {
+                                    lastEmbed.setFooter({ text: (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`) });
+                                }
+                            }
+                            if (channel) {
+                                await channel.send(messageOptions).catch((error) => {
+                                    logDeliveryError('renderDiscordResponse/send', error);
+                                });
+                            }
+                        }
+                        else if (finalOutputText && finalOutputText.trim().length > 0) {
+                            await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Final Output`, finalOutputText, PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
+                                source: 'complete',
+                                expectedVersion: responseVersion,
+                                components: components.length > 0 ? components : undefined,
+                            });
+                        }
+                        else {
+                            await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use `/screenshot` to verify.'), PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
+                                source: 'complete',
+                                expectedVersion: responseVersion,
+                                components: components.length > 0 ? components : undefined,
+                            });
+                        }
                         await sendGeneratedImages(finalOutputText || '');
                         await clearWatchingReaction();
                         await message.react(finalOutputText && finalOutputText.trim().length > 0 ? '✅' : '⚠️').catch(() => { });
@@ -770,6 +1021,32 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 }
             },
         });
+        onApprovalRef = async () => {
+            if (isFinalized)
+                return;
+            const textToUse = lastProgressText || monitor.getLastText() || '';
+            const separated = (0, discordFormatter_1.splitOutputAndLogs)(textToUse);
+            const outputText = separated.output || textToUse;
+            if (outputText && outputText.trim().length > 0) {
+                liveResponseUpdateVersion += 1;
+                const responseVersion = liveResponseUpdateVersion;
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                await upsertLiveResponseEmbeds((0, i18n_1.t)('Response'), outputText, PHASE_COLORS.thinking, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Awaiting Approval`), {
+                    source: 'approval-pause',
+                    expectedVersion: responseVersion,
+                    skipWhenFinalized: true,
+                }).catch(() => { });
+            }
+        };
+        cdp.on('approval_required', onApprovalRef);
+        if (options?.onMonitorCreated) {
+            options.onMonitorCreated({
+                stop: async () => {
+                    isFinalized = true;
+                    await monitor.stop();
+                }
+            });
+        }
         await monitor.start();
         // 1-second elapsed timer — updates footer independently of process log events
         const elapsedTimer = setInterval(() => {
@@ -834,6 +1111,8 @@ const startBot = async (cliLogLevel) => {
         .filter((account) => typeof account.userDataDir === 'string' && account.userDataDir.trim().length > 0)
         .map((account) => [account.name, account.userDataDir.trim()]));
     const bridge = (0, cdpBridgeManager_1.initCdpBridge)(config.autoApproveFileEdits, accountPorts, accountUserDataDirs);
+    bridge.chatSessionRepo = chatSessionRepo;
+    bridge.artifactService = artifactService;
     // Initialize CDP-dependent services (constructor CDP dependency removed)
     const chatSessionService = new chatSessionService_1.ChatSessionService();
     const titleGenerator = new titleGeneratorService_1.TitleGeneratorService();
@@ -884,7 +1163,20 @@ const startBot = async (cliLogLevel) => {
             accountPrefRepo,
             accounts: config.antigravityAccounts,
         });
-        await (0, antigravityLauncher_1.startAntigravity)(accountPorts[accountName] ?? 9222);
+        const status = await (0, antigravityLauncher_1.startAntigravity)(accountPorts[accountName] ?? 9222);
+        if (status === 'started') {
+            const cdp = new cdpService_1.CdpService({ portsToScan: [accountPorts[accountName] ?? 9222] });
+            try {
+                await cdp.connect();
+                await cdp.openChatPanel();
+            }
+            catch (e) {
+                // ignore
+            }
+            finally {
+                await cdp.disconnect().catch(() => { });
+            }
+        }
     });
     const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool, (channelId, userId) => (0, accountUtils_1.resolveScopedAccountName)({
         channelId,
@@ -977,6 +1269,7 @@ const startBot = async (cliLogLevel) => {
                 wsHandler,
                 chatHandler,
                 client,
+                promptDispatcher,
                 sendModeUI: modeUi_1.sendModeUI,
                 sendModelsUI: modelsUi_1.sendModelsUI,
                 sendAutoAcceptUI: autoAcceptUi_1.sendAutoAcceptUI,
@@ -984,6 +1277,7 @@ const startBot = async (cliLogLevel) => {
                 parseApprovalCustomId: cdpBridgeManager_1.parseApprovalCustomId,
                 parseErrorPopupCustomId: cdpBridgeManager_1.parseErrorPopupCustomId,
                 parsePlanningCustomId: cdpBridgeManager_1.parsePlanningCustomId,
+                parseFileChangeCustomId: cdpBridgeManager_1.parseFileChangeCustomId,
                 parseRunCommandCustomId: cdpBridgeManager_1.parseRunCommandCustomId,
                 joinHandler,
                 userPrefRepo,
@@ -993,8 +1287,10 @@ const startBot = async (cliLogLevel) => {
                 chatSessionService,
                 artifactThreadRepo,
                 artifactService,
+                channelManager,
+                titleGenerator,
                 antigravityAccounts: config.antigravityAccounts,
-                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepo, artifactService),
+                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, scheduleServiceArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, artifactService, scheduleServiceArg),
                 handleTemplateUse: async (interaction, templateId) => {
                     const template = templateRepo.findById(templateId);
                     if (!template) {
@@ -1035,6 +1331,7 @@ const startBot = async (cliLogLevel) => {
                             (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName, selectedAccount);
                             (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName, selectedAccount);
                             (0, cdpBridgeManager_1.ensureRunCommandDetector)(bridge, cdp, projectName, selectedAccount);
+                            (0, cdpBridgeManager_1.ensureQuestionDetector)(bridge, cdp, projectName, selectedAccount);
                         }
                         catch (e) {
                             await interaction.followUp({
@@ -1184,10 +1481,12 @@ const startBot = async (cliLogLevel) => {
                         : binding.workspacePath;
                 },
             });
+            const questionSelectAction = (0, questionSelectAction_1.createQuestionSelectAction)({ bridge, wsHandler });
             const telegramSelectHandler = (0, selectHandler_1.createPlatformSelectHandler)({
                 actions: [
                     modeSelectAction,
                     accountSelectAction,
+                    questionSelectAction,
                 ],
             });
             // Composite handler that routes to the right handler
@@ -1206,7 +1505,9 @@ const startBot = async (cliLogLevel) => {
                     }, interaction);
                     return;
                 }
-                if (interaction.customId === 'mode_select' || interaction.customId === 'account_select') {
+                if (interaction.customId === 'mode_select' ||
+                    interaction.customId === 'account_select' ||
+                    interaction.customId.startsWith('question_select_action')) {
                     await telegramSelectHandler(interaction);
                     return;
                 }
@@ -1221,10 +1522,10 @@ const startBot = async (cliLogLevel) => {
             }
             const telegramButtonHandler = (0, buttonHandler_1.createPlatformButtonHandler)({
                 actions: [
-                    (0, approvalButtonAction_1.createApprovalButtonAction)({ bridge }),
-                    (0, planningButtonAction_1.createPlanningButtonAction)({ bridge }),
-                    (0, errorPopupButtonAction_1.createErrorPopupButtonAction)({ bridge }),
-                    (0, runCommandButtonAction_1.createRunCommandButtonAction)({ bridge }),
+                    (0, approvalButtonAction_1.createApprovalButtonAction)({ bridge, wsHandler }),
+                    (0, planningButtonAction_1.createPlanningButtonAction)({ bridge, wsHandler }),
+                    (0, errorPopupButtonAction_1.createErrorPopupButtonAction)({ bridge, wsHandler }),
+                    (0, runCommandButtonAction_1.createRunCommandButtonAction)({ bridge, wsHandler }),
                     (0, modelButtonAction_1.createModelButtonAction)({
                         bridge,
                         fetchQuota: () => bridge.quota.fetchQuota(),
@@ -1262,6 +1563,8 @@ const startBot = async (cliLogLevel) => {
                     }),
                     (0, autoAcceptButtonAction_1.createAutoAcceptButtonAction)({ autoAcceptService: bridge.autoAccept }),
                     (0, templateButtonAction_1.createTemplateButtonAction)({ bridge, templateRepo }),
+                    (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge, wsHandler }),
+                    (0, genericActionButtonAction_1.createGenericActionButtonAction)({ bridge, wsHandler }),
                 ],
             });
             const eventRouter = new eventRouter_1.EventRouter({ allowedUsers }, {
@@ -1382,7 +1685,7 @@ async function autoRenameChannel(message, chatSessionRepo, titleGenerator, chann
 /**
  * Handle Discord Interactions API slash commands
  */
-async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, chatSessionService, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepo, channelPrefRepo, antigravityAccounts = [{ name: 'default', cdpPort: 9222 }], chatSessionRepo, artifactService) {
+async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, chatSessionService, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepo, channelPrefRepo, antigravityAccounts = [{ name: 'default', cdpPort: 9222 }], chatSessionRepo, artifactService, scheduleService) {
     const commandName = interaction.commandName;
     const getAccountPort = (accountName) => {
         const match = antigravityAccounts.find((account) => account.name === accountName);
@@ -1407,9 +1710,7 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             const projectName = bridge.pool.extractProjectName(workspacePath);
             return bridge.pool.getConnected(projectName, resolveSelectedAccount());
         }
-        return bridge.lastActiveWorkspace
-            ? bridge.pool.getConnected(bridge.lastActiveWorkspace, resolveSelectedAccount())
-            : null;
+        return null;
     })();
     const ensureChannelCdp = async () => {
         const existing = getChannelCdp();
@@ -1880,6 +2181,65 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             await interaction.editReply({ content: codeBlock });
             break;
         }
+        case 'open': {
+            const filepath = interaction.options.getString('filepath', true);
+            let resolvedPath = null;
+            // 1. Try to resolve as an artifact
+            if (chatSessionRepo && artifactService) {
+                const session = chatSessionRepo.findByChannelId(interaction.channelId);
+                if (session && session.conversationId) {
+                    const possibleArtifact = artifactService.getArtifactPath(session.conversationId, filepath);
+                    if (fs_1.default.existsSync(possibleArtifact)) {
+                        resolvedPath = possibleArtifact;
+                    }
+                }
+            }
+            // 2. Try to resolve against the workspace
+            if (!resolvedPath) {
+                const cdp = await ensureChannelCdp();
+                if (cdp) {
+                    const wsPath = cdp.getCurrentWorkspacePath();
+                    if (wsPath) {
+                        let rawPath = filepath;
+                        if (filepath.startsWith('file:///')) {
+                            rawPath = filepath.replace('file:///', '');
+                            if (process.platform === 'win32' && rawPath.startsWith('/')) {
+                                rawPath = rawPath.substring(1);
+                            }
+                        }
+                        const candidatePath = path_1.default.isAbsolute(rawPath) ? rawPath : path_1.default.join(wsPath, rawPath);
+                        const relative = path_1.default.relative(wsPath, candidatePath);
+                        if (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)) {
+                            if (fs_1.default.existsSync(candidatePath)) {
+                                resolvedPath = candidatePath;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!resolvedPath) {
+                await interaction.editReply({
+                    content: '❌ Error: Cannot resolve file path. Ensure the file exists as an artifact or within the current workspace.'
+                });
+                break;
+            }
+            try {
+                (0, child_process_1.execFile)((0, pathUtils_1.getAntigravityCliPath)(), [resolvedPath], (error) => {
+                    if (error) {
+                        logger_1.logger.error(`Failed to open file via CLI: ${error.message}`);
+                        interaction.editReply({ content: `❌ Error opening file via CLI.` }).catch(() => { });
+                    }
+                    else {
+                        interaction.editReply({ content: `✅ Opened file: **${path_1.default.basename(resolvedPath)}**` }).catch(() => { });
+                    }
+                });
+            }
+            catch (e) {
+                logger_1.logger.error(`Failed to open file: ${e.message}`);
+                await interaction.editReply({ content: `❌ Error opening file.` });
+            }
+            break;
+        }
         case 'artifacts': {
             await (0, artifactsUi_1.sendArtifactPickerUI)(interaction, {
                 userPrefRepo,