lazy-gravity 0.9.2 → 0.11.0

package/dist/events/messageCreateHandler.js

@@ -16,6 +16,7 @@ function createMessageCreateHandler(deps) {
     const ensureErrorPopupDetector = deps.ensureErrorPopupDetector ?? cdpBridgeManager_1.ensureErrorPopupDetector;
     const ensurePlanningDetector = deps.ensurePlanningDetector ?? cdpBridgeManager_1.ensurePlanningDetector;
     const ensureRunCommandDetector = deps.ensureRunCommandDetector ?? cdpBridgeManager_1.ensureRunCommandDetector;
+    const ensureQuestionDetector = deps.ensureQuestionDetector ?? cdpBridgeManager_1.ensureQuestionDetector;
     const registerApprovalWorkspaceChannel = deps.registerApprovalWorkspaceChannel ?? cdpBridgeManager_1.registerApprovalWorkspaceChannel;
     const registerApprovalSessionChannel = deps.registerApprovalSessionChannel ?? cdpBridgeManager_1.registerApprovalSessionChannel;
     const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
@@ -190,10 +191,60 @@ function createMessageCreateHandler(deps) {
             }
             return;
         }
-        const hasImageAttachments = Array.from(message.attachments.values())
-            .some((attachment) => isImageAttachment(attachment.contentType, attachment.name));
-        if (message.content.trim() || hasImageAttachments) {
-            const promptText = message.content.trim() || 'Please review the attached images and respond accordingly.';
+        const allAttachments = Array.from(message.attachments.values());
+        const hasImageAttachments = allAttachments.some((attachment) => isImageAttachment(attachment.contentType, attachment.name));
+        const MAX_TEXT_ATTACHMENT_SIZE = 50 * 1024; // 50KB
+        const textAttachments = allAttachments.filter((a) => {
+            if (isImageAttachment(a.contentType, a.name))
+                return false;
+            if (a.size > MAX_TEXT_ATTACHMENT_SIZE)
+                return false;
+            const isTextType = a.contentType?.startsWith('text/') || a.contentType?.startsWith('application/json') || a.contentType?.startsWith('application/javascript');
+            const hasTextExt = a.name?.match(/\.(txt|md|js|ts|py|json|html|css|csv|log|sh|yml|yaml|xml)$/i);
+            return isTextType || hasTextExt;
+        });
+        if (message.content.trim() || hasImageAttachments || textAttachments.length > 0) {
+            let promptText = message.content.trim() || 'Please review the attached content and respond accordingly.';
+            // Prepend reply context if replying to a message
+            if (message.reference && message.reference.messageId) {
+                try {
+                    const repliedTo = await message.channel.messages.fetch(message.reference.messageId);
+                    if (repliedTo) {
+                        const cleanContent = (repliedTo.content || '(Attachment/Embed)').trim();
+                        const truncated = cleanContent.length > 500 ? cleanContent.substring(0, 500) + '...' : cleanContent;
+                        promptText = `[Replying to context: "${truncated}"]\n\n${promptText}`;
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.warn('[MessageCreate] Failed to fetch replied-to message context:', e);
+                }
+            }
+            // Fetch and append text attachments in parallel with a small concurrency cap
+            const CONCURRENCY_LIMIT = 3;
+            for (let i = 0; i < textAttachments.length; i += CONCURRENCY_LIMIT) {
+                const chunk = textAttachments.slice(i, i + CONCURRENCY_LIMIT);
+                const results = await Promise.all(chunk.map(async (textAtt) => {
+                    try {
+                        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\`\`\``;
+                        }
+                        else {
+                            logger_1.logger.warn(`[MessageCreate] Non-ok status fetching text attachment ${textAtt.name}: ${res.status}`);
+                            return '';
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.warn(`[MessageCreate] Failed to fetch text attachment ${textAtt.name}:`, e);
+                        return '';
+                    }
+                }));
+                promptText += results.join('');
+            }
             const inboundImages = await downloadInboundImageAttachments(message);
             if (hasImageAttachments && inboundImages.length === 0) {
                 await message.reply('Failed to retrieve attached images. Please wait and try again.').catch(() => { });
@@ -253,6 +304,7 @@ function createMessageCreateHandler(deps) {
                             ensureErrorPopupDetector(deps.bridge, cdp, projectName, selectedAccount);
                             ensurePlanningDetector(deps.bridge, cdp, projectName, selectedAccount);
                             ensureRunCommandDetector(deps.bridge, cdp, projectName, selectedAccount);
+                            ensureQuestionDetector(deps.bridge, cdp, projectName, selectedAccount);
                             let session = deps.chatSessionRepo.findByChannelId(message.channelId);
                             const staleSessionAccount = session?.isRenamed
                                 && ((session.activeAccountName && session.activeAccountName !== selectedAccount)
@@ -300,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/__tests__/fileChangeButtonAction.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileChangeButtonAction_1 = require("../fileChangeButtonAction");
+describe('fileChangeButtonAction', () => {
+    let mockInteraction;
+    let mockCdp;
+    let mockBridge;
+    let mockWsHandler;
+    beforeEach(() => {
+        mockInteraction = {
+            deferUpdate: jest.fn().mockResolvedValue(undefined),
+            reply: jest.fn().mockResolvedValue(undefined),
+            update: jest.fn().mockResolvedValue(undefined),
+            followUp: jest.fn().mockResolvedValue(undefined),
+        };
+        mockCdp = {
+            isConnected: jest.fn().mockReturnValue(true),
+            call: jest.fn(),
+        };
+        mockBridge = {
+            lastActiveWorkspace: 'test_project',
+            pool: {
+                getConnected: jest.fn().mockReturnValue(mockCdp),
+                extractProjectName: jest.fn().mockReturnValue('test_project'),
+            },
+        };
+        mockWsHandler = {
+            getWorkspaceForChannel: jest.fn().mockReturnValue('test_project'),
+        };
+    });
+    it('matches valid legacy custom IDs', () => {
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        expect(action.match('ide_file_accept_all')).toEqual({ action: 'accept', projectName: '', channelId: '' });
+        expect(action.match('ide_file_reject_all')).toEqual({ action: 'reject', projectName: '', channelId: '' });
+        expect(action.match('unknown_button')).toBeNull();
+    });
+    it('matches valid custom IDs with project and channel', () => {
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        expect(action.match('file_change_accept:proj:chan1')).toEqual({ action: 'accept', projectName: 'proj', channelId: 'chan1' });
+        expect(action.match('file_change_reject:proj:chan2')).toEqual({ action: 'reject', projectName: 'proj', channelId: 'chan2' });
+    });
+    it('fails if linked to a different session channel', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept', channelId: 'channel_456' });
+        expect(mockInteraction.reply).toHaveBeenCalledWith({ text: 'This file change action is linked to a different session channel.' });
+    });
+    it('fails if not connected to IDE', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.isConnected.mockReturnValue(false);
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept', channelId: 'channel_123' });
+        expect(mockInteraction.reply).toHaveBeenCalledWith({ text: 'Not connected to IDE.' });
+    });
+    it('successfully accepts changes when button is found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: true } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept' });
+        expect(mockCdp.call).toHaveBeenCalled();
+        expect(mockInteraction.update).toHaveBeenCalledWith({
+            text: '✅ Accepted file changes.',
+            components: [],
+        });
+    });
+    it('successfully rejects changes when button is found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: true } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'reject' });
+        expect(mockInteraction.update).toHaveBeenCalledWith({
+            text: '❌ Rejected file changes.',
+            components: [],
+        });
+    });
+    it('sends followup if button is not found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: false } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept' });
+        expect(mockInteraction.followUp).toHaveBeenCalledWith({
+            text: expect.stringContaining('Could not find the "Accept all" button'),
+        });
+    });
+});

package/dist/handlers/approvalButtonAction.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApprovalButtonAction = createApprovalButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
 function createApprovalButtonAction(deps) {
     return {
@@ -32,7 +33,7 @@ function createApprovalButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             logger_1.logger.debug(`[ApprovalAction] action=${action} project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
             const detector = projectName
                 ? deps.bridge.pool.getApprovalDetector(projectName)

package/dist/handlers/errorPopupButtonAction.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorPopupButtonAction = createErrorPopupButtonAction;
+const projectResolver_1 = require("../utils/projectResolver");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const logger_1 = require("../utils/logger");
 const MAX_DEBUG_CONTENT = 4096;
@@ -30,7 +31,7 @@ function createErrorPopupButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             const detector = projectName
                 ? deps.bridge.pool.getErrorPopupDetector(projectName)
                 : undefined;

package/dist/handlers/fileChangeButtonAction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileChangeButtonAction = createFileChangeButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
+const logger_1 = require("../utils/logger");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
+function createFileChangeButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parseFileChangeCustomId)(customId);
+            if (!parsed)
+                return null;
+            return {
+                action: parsed.action,
+                projectName: parsed.projectName ?? '',
+                channelId: parsed.channelId ?? '',
+            };
+        },
+        async execute(interaction, params) {
+            const { action, channelId } = params;
+            // Acknowledge immediately so Telegram/Discord doesn't time out
+            await interaction.deferUpdate().catch(() => { });
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This file change action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
+            const cdp = projectName ? deps.bridge.pool.getConnected(projectName) : undefined;
+            if (!cdp || !cdp.isConnected()) {
+                await interaction
+                    .reply({ text: 'Not connected to IDE.' })
+                    .catch(() => { });
+                return;
+            }
+            const targetText = action === 'accept' ? 'Accept all' : 'Reject all';
+            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);
+                });
+            }
+            else {
+                await interaction
+                    .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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGenericActionCustomId = parseGenericActionCustomId;
+exports.createGenericActionButtonAction = createGenericActionButtonAction;
+const logger_1 = require("../utils/logger");
+const projectResolver_1 = require("../utils/projectResolver");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
+function parseGenericActionCustomId(customId) {
+    if (!customId.startsWith('action_btn_'))
+        return null;
+    const parts = customId.split(':');
+    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: projectName || undefined,
+        channelId: channelId || undefined,
+    };
+}
+function createGenericActionButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = parseGenericActionCustomId(customId);
+            if (!parsed)
+                return null;
+            const result = { actionName: parsed.actionName };
+            if (parsed.projectName)
+                result.projectName = parsed.projectName;
+            if (parsed.channelId)
+                result.channelId = parsed.channelId;
+            return result;
+        },
+        async execute(interaction, params) {
+            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, accountName)
+                : null;
+            if (!cdp) {
+                await interaction.followUp({
+                    text: 'Not connected to Antigravity. Send the action as a message instead.',
+                }).catch(() => { });
+                return;
+            }
+            // Simulate DOM click instead of chat injection
+            logger_1.logger.info(`[GenericActionButton] Clicking action button "${actionName}" via DOM script`);
+            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(() => { });
+                return;
+            }
+        },
+    };
+}

package/dist/handlers/planningButtonAction.js

@@ -5,10 +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 {
@@ -24,35 +62,66 @@ 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;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             const detector = projectName
                 ? 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 clicked = await detector.clickOpenButton();
-                if (!clicked) {
-                    await interaction
-                        .reply({ text: 'Open button not found.' })
-                        .catch(() => { });
-                    return;
+                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;
+                    }
                 }
-                // Wait for DOM to update after Open click
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                // Extract plan content with retry
+                // Acknowledge if we didn't show a modal
+                await interaction.deferUpdate().catch(() => { });
+                let clicked = false;
+                if (info?.hasOpenButton && (!isReview || modalFailed)) {
+                    try {
+                        clicked = await detector.clickOpenButton();
+                        if (clicked) {
+                            await new Promise((resolve) => setTimeout(resolve, 500));
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.error('[PlanningAction] clickOpenButton failed:', e);
+                    }
+                }
+                // 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();
@@ -60,16 +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
+                        .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
@@ -80,10 +175,18 @@ 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.followUp({ text: 'Rejection of the plan is not allowed.', ephemeral: true }).catch(() => { });
+                return;
+            }
             else {
                 // Proceed action
                 await interaction.deferUpdate().catch(() => { });
@@ -99,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(() => { });
                 }
             }

package/dist/handlers/planningModalSubmitAction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+async function execute(interaction, projectName, pool, accountName) {
+    try {
+        if (!projectName) {
+            await interaction.reply({ text: (0, i18n_1.t)('Project name not found.'), ephemeral: true });
+            return;
+        }
+        const cdp = pool.getConnected(projectName, accountName);
+        if (!cdp) {
+            await interaction.reply({ text: (0, i18n_1.t)('Not connected to workspace.'), ephemeral: true });
+            return;
+        }
+        const comment = interaction.fields.get('comment')?.trim();
+        if (!comment) {
+            await interaction.reply({ text: (0, i18n_1.t)('Comment cannot be empty.'), ephemeral: true });
+            return;
+        }
+        await interaction.deferUpdate();
+        // Inject the comment into the chat
+        const result = await cdp.injectMessage(comment);
+        if (!result.ok) {
+            await interaction.followUp({ text: (0, i18n_1.t)('Failed to submit comment: {{error}}', { error: result.error }), ephemeral: true });
+            return;
+        }
+        await interaction.followUp({ text: (0, i18n_1.t)('Comment submitted to the plan successfully.'), ephemeral: true });
+    }
+    catch (error) {
+        logger_1.logger.error('[PlanningModalSubmit] Error:', error);
+        try {
+            await interaction.followUp({ text: (0, i18n_1.t)('An error occurred while submitting your comment.'), ephemeral: true });
+        }
+        catch { /* ignore */ }
+    }
+}