lazy-gravity 0.10.0 → 0.11.0

package/dist/events/interactionCreateHandler.js

@@ -21,6 +21,8 @@ const notificationSender_1 = require("../services/notificationSender");
 const questionSelectAction_1 = require("../handlers/questionSelectAction");
 const questionSkipAction_1 = require("../handlers/questionSkipAction");
 const wrappers_1 = require("../platform/discord/wrappers");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
+const projectResolver_1 = require("../utils/projectResolver");
 const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
 const projectListUi_1 = require("../ui/projectListUi");
 const modeService_1 = require("../services/modeService");
@@ -226,6 +228,19 @@ function createInteractionCreateHandler(deps) {
                                 embeds: [updatedEmbed],
                                 components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
                             });
+                            if (success && (approvalAction.action === 'approve' || approvalAction.action === 'always_allow') && deps.promptDispatcher && interaction.channelId && interaction.message) {
+                                const cdp = projectName
+                                    ? deps.bridge.pool.getConnected(projectName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction)))
+                                    : null;
+                                if (cdp) {
+                                    deps.promptDispatcher.resume({
+                                        message: interaction.message,
+                                        prompt: '',
+                                        cdp,
+                                        options: buildResumeOptions()
+                                    }).catch(e => logger_1.logger.error('[Approval] Failed to resume monitoring:', e));
+                                }
+                            }
                         }
                         else {
                             await interaction.reply({ content: 'Approval button not found.', flags: discord_js_1.MessageFlags.Ephemeral });
@@ -873,8 +888,39 @@ function createInteractionCreateHandler(deps) {
                 }
                 if (interaction.customId.startsWith('file_open:')) {
                     await interaction.deferUpdate().catch(() => { });
-                    const hashId = interaction.customId.replace('file_open:', '');
-                    const fileUrl = fileOpenCache_1.fileOpenCache.get(hashId);
+                    let fileUrl = undefined;
+                    const suffix = interaction.customId.substring('file_open:'.length);
+                    if (suffix.startsWith('rel:')) {
+                        const relativePath = suffix.substring('rel:'.length);
+                        const workspacePath = interaction.channelId ? (deps.wsHandler.getWorkspaceForChannel(interaction.channelId) ||
+                            deps.chatSessionRepo?.findByChannelId(interaction.channelId)?.workspacePath) : undefined;
+                        if (workspacePath) {
+                            fileUrl = `file:///${path_1.default.join(workspacePath, relativePath).replace(/\\/g, '/')}`;
+                        }
+                    }
+                    else if (suffix.startsWith('art:')) {
+                        const parts = suffix.substring('art:'.length).split(':');
+                        if (parts.length >= 2) {
+                            const convId = parts[0];
+                            const filename = parts.slice(1).join(':');
+                            if (deps.artifactService) {
+                                const artifacts = deps.artifactService.listArtifacts(convId);
+                                const matched = artifacts.find(art => art.filename.toLowerCase() === filename.toLowerCase());
+                                if (matched) {
+                                    fileUrl = `file:///${matched.absolutePath.replace(/\\/g, '/')}`;
+                                }
+                            }
+                            if (!fileUrl) {
+                                const brainDir = path_1.default.join(require('os').homedir(), '.gemini', 'antigravity', 'brain');
+                                fileUrl = `file:///${path_1.default.join(brainDir, convId, filename).replace(/\\/g, '/')}`;
+                            }
+                        }
+                    }
+                    else {
+                        // Fallback to cache (for legacy file_open:<hashId> or explicit cache usage)
+                        const hashId = suffix.startsWith('cache:') ? suffix.substring('cache:'.length) : suffix;
+                        fileUrl = fileOpenCache_1.fileOpenCache.get(hashId);
+                    }
                     if (!fileUrl) {
                         await interaction.followUp({
                             content: (0, i18n_1.t)('File URL not found in cache or expired.'),
@@ -893,37 +939,58 @@ function createInteractionCreateHandler(deps) {
                         }
                         resolvedPath = path_1.default.resolve(rawPath);
                     }
-                    let workspacePath = undefined;
-                    if (interaction.channelId) {
-                        workspacePath = deps.wsHandler.getWorkspaceForChannel(interaction.channelId) ||
-                            deps.chatSessionRepo?.findByChannelId(interaction.channelId)?.workspacePath;
-                    }
-                    if (!workspacePath) {
-                        await interaction.followUp({
-                            content: `❌ Error: Cannot open files without an active workspace.`,
-                            flags: discord_js_1.MessageFlags.Ephemeral
-                        }).catch(logger_1.logger.error);
-                        return;
-                    }
-                    const relative = path_1.default.relative(workspacePath, resolvedPath);
-                    if (relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
-                        await interaction.followUp({
-                            content: `❌ Error: Cannot open files outside the workspace root.`,
-                            flags: discord_js_1.MessageFlags.Ephemeral
-                        }).catch(logger_1.logger.error);
-                        return;
+                    const isArtifact = resolvedPath.includes('.gemini') && resolvedPath.includes('antigravity') && resolvedPath.includes('brain');
+                    if (!isArtifact) {
+                        let workspacePath = undefined;
+                        if (interaction.channelId) {
+                            workspacePath = deps.wsHandler.getWorkspaceForChannel(interaction.channelId) ||
+                                deps.chatSessionRepo?.findByChannelId(interaction.channelId)?.workspacePath;
+                        }
+                        if (!workspacePath) {
+                            await interaction.followUp({
+                                content: `❌ Error: Cannot open files without an active workspace.`,
+                                flags: discord_js_1.MessageFlags.Ephemeral
+                            }).catch(logger_1.logger.error);
+                            return;
+                        }
+                        const resolvedWorkspacePath = path_1.default.resolve(workspacePath);
+                        const relative = path_1.default.relative(resolvedWorkspacePath, resolvedPath);
+                        if (relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
+                            await interaction.followUp({
+                                content: `❌ Error: Cannot open files outside the workspace root.`,
+                                flags: discord_js_1.MessageFlags.Ephemeral
+                            }).catch(logger_1.logger.error);
+                            return;
+                        }
                     }
                     try {
+                        const comp = interaction.component;
+                        const buttonLabel = comp?.type === 2 ? comp.label : null;
+                        const isReviewBtn = suffix.startsWith('art:') ||
+                            buttonLabel?.toLowerCase().includes('review') ||
+                            resolvedPath.endsWith('walkthrough.md') ||
+                            resolvedPath.endsWith('task.md') ||
+                            resolvedPath.endsWith('implementation_plan.md');
                         const fileContent = fs_1.default.readFileSync(resolvedPath, 'utf8');
                         const MAX_DESC_LEN = 4096;
-                        const truncated = fileContent.length > MAX_DESC_LEN
+                        let truncated = fileContent.length > MAX_DESC_LEN
                             ? fileContent.substring(0, MAX_DESC_LEN - 15) + '\n\n(truncated)'
                             : fileContent;
+                        if (isReviewBtn) {
+                            truncated += '\n\n💡 *To request changes to this artifact, simply reply in this channel.*';
+                        }
                         const embed = new discord_js_1.EmbedBuilder()
-                            .setTitle(`Opened: ${path_1.default.basename(resolvedPath)}`)
+                            .setTitle(isReviewBtn ? `Reviewing: ${path_1.default.basename(resolvedPath)}` : `Opened: ${path_1.default.basename(resolvedPath)}`)
                             .setDescription(truncated)
-                            .setColor(0x3498DB)
+                            .setColor(isReviewBtn ? 0x2ECC71 : 0x3498DB)
                             .setTimestamp();
+                        if (isReviewBtn) {
+                            await interaction.followUp({
+                                embeds: [embed],
+                                components: []
+                            }).catch(logger_1.logger.error);
+                            return;
+                        }
                         (0, child_process_1.execFile)((0, pathUtils_1.getAntigravityCliPath)(), [resolvedPath], async (error) => {
                             if (error) {
                                 logger_1.logger.error(`Failed to open file via CLI: ${error.message}`);
@@ -933,9 +1000,14 @@ function createInteractionCreateHandler(deps) {
                                 }).catch(() => { });
                             }
                             else {
+                                const closeRow = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+                                    .setCustomId('file_close_active')
+                                    .setLabel('Close Active Tab in IDE')
+                                    .setStyle(discord_js_1.ButtonStyle.Secondary));
                                 await interaction.followUp({
                                     content: `✅ Opened file in IDE: **${path_1.default.basename(resolvedPath)}**`,
                                     embeds: [embed],
+                                    components: [closeRow],
                                     flags: discord_js_1.MessageFlags.Ephemeral
                                 }).catch(() => { });
                             }
@@ -949,9 +1021,38 @@ function createInteractionCreateHandler(deps) {
                     }
                     return;
                 }
+                if (interaction.customId === 'file_close_active') {
+                    await interaction.deferUpdate().catch(() => { });
+                    try {
+                        const cdp = deps.getCurrentCdp(deps.bridge);
+                        if (!cdp) {
+                            await interaction.followUp({
+                                content: `❌ No active CDP connection found.`,
+                                flags: discord_js_1.MessageFlags.Ephemeral
+                            }).catch(() => { });
+                            return;
+                        }
+                        if (!cdp.isConnected()) {
+                            await cdp.connect();
+                        }
+                        await cdp.closeActiveEditor();
+                        await interaction.followUp({
+                            content: `✅ Sent close command to IDE.`,
+                            flags: discord_js_1.MessageFlags.Ephemeral
+                        }).catch(() => { });
+                    }
+                    catch (e) {
+                        logger_1.logger.error(`Failed to close active editor: ${e.message}`);
+                        await interaction.followUp({
+                            content: `❌ Error closing editor: ${e.message}`,
+                            flags: discord_js_1.MessageFlags.Ephemeral
+                        }).catch(() => { });
+                    }
+                    return;
+                }
             }
             catch (error) {
-                logger_1.logger.error('Error during button interaction handling:', error);
+                logger_1.logger.error(`[InteractionCreate] Error handling interaction: ${error instanceof Error ? error.message : String(error)}`);
                 try {
                     if (!interaction.replied && !interaction.deferred) {
                         await interaction.reply({ content: 'An error occurred while processing the button action.', flags: discord_js_1.MessageFlags.Ephemeral });
@@ -1243,7 +1344,22 @@ function createInteractionCreateHandler(deps) {
             try {
                 const action = (0, questionSelectAction_1.createQuestionSelectAction)({ bridge: deps.bridge, wsHandler: deps.wsHandler });
                 const wrapped = (0, wrappers_1.wrapDiscordSelect)(interaction);
-                await action.execute(wrapped, interaction.values);
+                const success = await action.execute(wrapped, interaction.values);
+                if (success && deps.promptDispatcher && interaction.channelId && interaction.message) {
+                    const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SELECT_ACTION_PREFIX);
+                    if (parsed) {
+                        const projectName = (0, projectResolver_1.resolveProjectName)({ bridge: deps.bridge, wsHandler: deps.wsHandler }, interaction.channelId, parsed.projectName);
+                        const cdp = projectName ? deps.bridge.pool.getConnected(projectName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction))) : null;
+                        if (cdp) {
+                            deps.promptDispatcher.resume({
+                                message: interaction.message,
+                                prompt: '',
+                                cdp,
+                                options: buildResumeOptions()
+                            }).catch(e => logger_1.logger.error('[QuestionSelectAction] Failed to resume monitoring:', e));
+                        }
+                    }
+                }
             }
             catch (err) {
                 logger_1.logger.error('[QuestionSelectAction] Error executing action:', err);
@@ -1260,7 +1376,22 @@ function createInteractionCreateHandler(deps) {
             try {
                 const action = (0, questionSkipAction_1.createQuestionSkipAction)({ bridge: deps.bridge, wsHandler: deps.wsHandler });
                 const wrapped = (0, wrappers_1.wrapDiscordButton)(interaction);
-                await action.execute(wrapped, {});
+                const success = await action.execute(wrapped, {});
+                if (success && deps.promptDispatcher && interaction.channelId && interaction.message) {
+                    const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SKIP_ACTION_PREFIX);
+                    if (parsed) {
+                        const projectName = (0, projectResolver_1.resolveProjectName)({ bridge: deps.bridge, wsHandler: deps.wsHandler }, interaction.channelId, parsed.projectName);
+                        const cdp = projectName ? deps.bridge.pool.getConnected(projectName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction))) : null;
+                        if (cdp) {
+                            deps.promptDispatcher.resume({
+                                message: interaction.message,
+                                prompt: '',
+                                cdp,
+                                options: buildResumeOptions()
+                            }).catch(e => logger_1.logger.error('[QuestionSkipAction] Failed to resume monitoring:', e));
+                        }
+                    }
+                }
             }
             catch (err) {
                 logger_1.logger.error('[QuestionSkipAction] Error executing action:', err);

package/dist/events/messageCreateHandler.js

@@ -225,7 +225,10 @@ function createMessageCreateHandler(deps) {
                 const chunk = textAttachments.slice(i, i + CONCURRENCY_LIMIT);
                 const results = await Promise.all(chunk.map(async (textAtt) => {
                     try {
-                        const res = await fetch(textAtt.url);
+                        const controller = new AbortController();
+                        const timeoutId = setTimeout(() => controller.abort(), 10000);
+                        const res = await fetch(textAtt.url, { signal: controller.signal });
+                        clearTimeout(timeoutId);
                         if (res.ok) {
                             const content = await res.text();
                             return `\n\n[Attached File: ${textAtt.name}]\n\`\`\`\n${content}\n\`\`\``;
@@ -349,9 +352,16 @@ function createMessageCreateHandler(deps) {
                                         }
                                     }
                                     if (!activationResult.ok) {
-                                        const reason = activationResult.error ? ` (${activationResult.error})` : '';
-                                        await message.reply(`⚠️ Could not route this message to the bound session (${session.displayName}). ` +
-                                            `Please open /chat and verify the session${reason}.`).catch(() => { });
+                                        const isDeleted = activationResult.error?.includes('Conversation not found in Past Conversations');
+                                        let replyText = `⚠️ Could not route this message to the bound session (${session.displayName}).\n*Reason: ${activationResult.error}*`;
+                                        if (isDeleted) {
+                                            deps.chatSessionRepo.deleteByChannelId(message.channelId);
+                                            replyText += `\n\n💡 **Tip**: This session appears to have been deleted in the IDE. I have unbound this channel so your next message will start a fresh chat. You can also type \`/new\` anytime.`;
+                                        }
+                                        else {
+                                            replyText += `\n\n💡 If this session is broken, type \`/new\` to force a new chat.`;
+                                        }
+                                        await message.reply(replyText).catch(() => { });
                                         return;
                                     }
                                 }

package/dist/handlers/fileChangeButtonAction.js

@@ -4,7 +4,7 @@ exports.createFileChangeButtonAction = createFileChangeButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
-const approvalDetector_1 = require("../services/approvalDetector");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
 function createFileChangeButtonAction(deps) {
     return {
         match(customId) {
@@ -36,32 +36,20 @@ function createFileChangeButtonAction(deps) {
                 return;
             }
             const targetText = action === 'accept' ? 'Accept all' : 'Reject all';
-            try {
-                const result = await cdp.call('Runtime.evaluate', {
-                    expression: (0, approvalDetector_1.buildClickScript)(targetText),
-                    returnByValue: true,
-                    awaitPromise: true,
+            const success = await (0, questionActionUtils_1.executeBrowserClick)(cdp, targetText);
+            if (success) {
+                await interaction
+                    .update({
+                    text: `${action === 'accept' ? '✅ Accepted' : '❌ Rejected'} file changes.`,
+                    components: [],
+                })
+                    .catch((err) => {
+                    logger_1.logger.warn('[FileChangeAction] update failed:', err);
                 });
-                if (result?.result?.value?.ok) {
-                    await interaction
-                        .update({
-                        text: `${action === 'accept' ? '✅ Accepted' : '❌ Rejected'} file changes.`,
-                        components: [],
-                    })
-                        .catch((err) => {
-                        logger_1.logger.warn('[FileChangeAction] update failed:', err);
-                    });
-                }
-                else {
-                    await interaction
-                        .followUp({ text: `Could not find the "${targetText}" button in the IDE. The file change prompt may have been dismissed.` })
-                        .catch(() => { });
-                }
             }
-            catch (error) {
-                logger_1.logger.error('[FileChangeAction] Error clicking button:', error);
+            else {
                 await interaction
-                    .followUp({ text: 'An error occurred while interacting with the IDE.' })
+                    .followUp({ text: `Could not find the "${targetText}" button in the IDE. The file change prompt may have been dismissed.` })
                     .catch(() => { });
             }
         },

package/dist/handlers/genericActionButtonAction.js

@@ -4,14 +4,7 @@ exports.parseGenericActionCustomId = parseGenericActionCustomId;
 exports.createGenericActionButtonAction = createGenericActionButtonAction;
 const logger_1 = require("../utils/logger");
 const projectResolver_1 = require("../utils/projectResolver");
-const approvalDetector_1 = require("../services/approvalDetector");
-/**
- * Parses a generic action button customId into its components.
- * Format: action_btn_[action_name]:[project_name]:[channel_id]
- *
- * @param customId The customId to parse
- * @returns Parsed action details, or null if not an action button
- */
+const questionActionUtils_1 = require("../utils/questionActionUtils");
 function parseGenericActionCustomId(customId) {
     if (!customId.startsWith('action_btn_'))
         return null;
@@ -19,10 +12,15 @@ function parseGenericActionCustomId(customId) {
     const actionName = parts[0].replace('action_btn_', '').replace(/_/g, ' ');
     // Capitalize first letter
     const formattedName = actionName.charAt(0).toUpperCase() + actionName.slice(1);
+    if (parts.length < 3) {
+        return { actionName: formattedName };
+    }
+    const channelId = parts[parts.length - 1];
+    const projectName = parts.slice(1, parts.length - 1).join(':');
     return {
         actionName: formattedName,
-        projectName: parts[1] || undefined,
-        channelId: parts[2] || undefined,
+        projectName: projectName || undefined,
+        channelId: channelId || undefined,
     };
 }
 function createGenericActionButtonAction(deps) {
@@ -42,12 +40,17 @@ function createGenericActionButtonAction(deps) {
             const actionName = params.actionName;
             const channelId = params.channelId || interaction.channel?.id;
             if (!channelId) {
+                await interaction.reply({
+                    text: 'Error: Cannot resolve channel ID.',
+                    ephemeral: true,
+                }).catch(() => { });
                 return;
             }
             const projectName = (0, projectResolver_1.resolveProjectName)(deps, channelId, params.projectName);
             await interaction.deferUpdate().catch(() => { });
+            const accountName = deps.bridge.selectedAccountByChannel?.get(channelId) || 'default';
             const cdp = projectName
-                ? deps.bridge.pool.getConnected(projectName)
+                ? deps.bridge.pool.getConnected(projectName, accountName)
                 : null;
             if (!cdp) {
                 await interaction.followUp({
@@ -57,13 +60,8 @@ function createGenericActionButtonAction(deps) {
             }
             // Simulate DOM click instead of chat injection
             logger_1.logger.info(`[GenericActionButton] Clicking action button "${actionName}" via DOM script`);
-            const script = (0, approvalDetector_1.buildClickScript)(actionName);
-            const evalResult = await cdp.call('Runtime.evaluate', {
-                expression: script,
-                returnByValue: true,
-            });
-            const resultValue = evalResult.result?.value;
-            if (!resultValue?.ok) {
+            const success = await (0, questionActionUtils_1.executeBrowserClick)(cdp, actionName);
+            if (!success) {
                 await interaction.followUp({
                     text: `Failed to execute action: Button "${actionName}" not found or obscured.`,
                 }).catch(() => { });

package/dist/handlers/planningButtonAction.js

@@ -5,11 +5,48 @@
  * Handles Open / Proceed button presses for the planning mode dialog
  * from both Discord and Telegram using the ButtonAction interface.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPlanningButtonAction = createPlanningButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const pathUtils_1 = require("../utils/pathUtils");
 const MAX_PLAN_CONTENT = 4096;
 function createPlanningButtonAction(deps) {
     return {
@@ -25,11 +62,10 @@ function createPlanningButtonAction(deps) {
         },
         async execute(interaction, params) {
             const { action, channelId } = params;
-            // Acknowledge immediately so Telegram doesn't time out
-            await interaction.deferUpdate().catch(() => { });
             if (channelId && channelId !== interaction.channel.id) {
+                await interaction.deferUpdate().catch(() => { });
                 await interaction
-                    .reply({ text: 'This planning action is linked to a different session channel.' })
+                    .followUp({ text: 'This planning action is linked to a different session channel.', ephemeral: true })
                     .catch(() => { });
                 return;
             }
@@ -38,14 +74,42 @@ function createPlanningButtonAction(deps) {
                 ? deps.bridge.pool.getPlanningDetector(projectName)
                 : undefined;
             if (!detector) {
+                await interaction.deferUpdate().catch(() => { });
                 await interaction
-                    .reply({ text: 'Planning detector not found.' })
+                    .followUp({ text: 'Planning detector not found.', ephemeral: true })
                     .catch(() => { });
                 return;
             }
             if (action === 'open') {
+                const info = detector.getLastDetectedInfo();
+                const isReview = info?.openText?.toLowerCase().includes('review');
+                let modalFailed = false;
+                if (isReview && interaction.showModal) {
+                    try {
+                        await interaction.showModal({
+                            title: 'Submit Comment',
+                            customId: `plan_comment_${projectName || ''}_${channelId}`,
+                            components: [{
+                                    components: [{
+                                            type: 'textInput',
+                                            customId: 'comment',
+                                            label: 'Add a message...',
+                                            style: 'paragraph',
+                                            required: false
+                                        }]
+                                }]
+                        });
+                        return;
+                    }
+                    catch (err) {
+                        logger_1.logger.error('[PlanningAction] showModal failed:', err);
+                        modalFailed = true;
+                    }
+                }
+                // Acknowledge if we didn't show a modal
+                await interaction.deferUpdate().catch(() => { });
                 let clicked = false;
-                if (detector.getLastDetectedInfo()?.hasOpenButton) {
+                if (info?.hasOpenButton && (!isReview || modalFailed)) {
                     try {
                         clicked = await detector.clickOpenButton();
                         if (clicked) {
@@ -56,7 +120,8 @@ function createPlanningButtonAction(deps) {
                         logger_1.logger.error('[PlanningAction] clickOpenButton failed:', e);
                     }
                 }
-                // Extract plan content with retry
+                // Since we only come here if it's NOT a review (or modal failed),
+                // we can just extract plan content and followUp
                 let planContent = null;
                 for (let attempt = 0; attempt < 3; attempt++) {
                     planContent = await detector.extractPlanContent();
@@ -64,22 +129,42 @@ function createPlanningButtonAction(deps) {
                         break;
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
+                if (!planContent && !clicked) {
+                    // Fallback to reading implementation_plan.md from the workspace
+                    const workspaceId = deps.wsHandler.getWorkspaceForChannel(interaction.channel.id);
+                    if (workspaceId) {
+                        const planFile = path.join(workspaceId, 'implementation_plan.md');
+                        if (fs.existsSync(planFile)) {
+                            try {
+                                planContent = fs.readFileSync(planFile, 'utf8');
+                                // Proactively open the file in the IDE
+                                (0, child_process_1.execFile)((0, pathUtils_1.getAntigravityCliPath)(), [planFile], (err) => {
+                                    if (err)
+                                        logger_1.logger.error(`[PlanningAction] Failed to open plan via CLI: ${err.message}`);
+                                });
+                            }
+                            catch (err) {
+                                logger_1.logger.error(`[PlanningAction] Failed to read plan file: ${err.message}`);
+                            }
+                        }
+                    }
+                }
                 if (!planContent && !clicked) {
                     await interaction
-                        .reply({ text: 'Plan content could not be extracted from the IDE.' })
+                        .followUp({ text: 'Plan content could not be extracted from the IDE or workspace.' })
                         .catch(() => { });
                     return;
                 }
                 await interaction
-                    .update({
+                    .editReply({
                     text: '📋 Plan opened',
                     components: [],
                 })
                     .catch((err) => {
-                    logger_1.logger.warn('[PlanningAction] update failed:', err);
+                    logger_1.logger.warn('[PlanningAction] editReply failed:', err);
                 });
                 if (planContent) {
-                    const truncated = planContent.length > MAX_PLAN_CONTENT
+                    let truncated = planContent.length > MAX_PLAN_CONTENT
                         ? planContent.substring(0, MAX_PLAN_CONTENT - 15) + '\n\n(truncated)'
                         : planContent;
                     await interaction
@@ -90,13 +175,16 @@ function createPlanningButtonAction(deps) {
                 }
                 else {
                     await interaction
-                        .followUp({ text: 'Could not extract plan content from the editor.' })
-                        .catch(() => { });
+                        .followUp({ text: 'Plan opened in IDE, but content could not be extracted.' })
+                        .catch((err) => {
+                        logger_1.logger.warn('[PlanningAction] followUp failed:', err);
+                    });
                 }
             }
             else if (action === 'reject') {
+                await interaction.deferUpdate().catch(() => { });
                 // Reject action
-                await interaction.reply({ text: 'Rejection of the plan is not allowed.' }).catch(() => { });
+                await interaction.followUp({ text: 'Rejection of the plan is not allowed.', ephemeral: true }).catch(() => { });
                 return;
             }
             else {
@@ -114,17 +202,17 @@ function createPlanningButtonAction(deps) {
                 }
                 if (clicked) {
                     await interaction
-                        .update({
-                        text: '▶️ Proceed started',
+                        .editReply({
+                        text: '▶️ Proceed started.\n\n⏳ IDE is working on the response...',
                         components: [],
                     })
                         .catch((err) => {
-                        logger_1.logger.warn('[PlanningAction] update failed:', err);
+                        logger_1.logger.warn('[PlanningAction] editReply failed:', err);
                     });
                 }
                 else {
                     await interaction
-                        .reply({ text: 'Proceed button not found.' })
+                        .followUp({ text: 'Proceed button not found.', ephemeral: true })
                         .catch(() => { });
                 }
             }