lazy-gravity 0.1.0 → 0.2.0

package/dist/database/userPreferenceRepository.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPreferenceRepository = void 0;
+/**
+ * Repository class for SQLite persistence of per-user preferences.
+ * Currently stores output format preference (embed vs plain text).
+ */
+class UserPreferenceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Initialize table (create if not exists)
+     */
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS user_preferences (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL UNIQUE,
+                output_format TEXT NOT NULL DEFAULT 'embed',
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    /**
+     * Get the output format preference for a user.
+     * Returns 'embed' as default if no preference is stored.
+     */
+    getOutputFormat(userId) {
+        const row = this.db.prepare('SELECT output_format FROM user_preferences WHERE user_id = ?').get(userId);
+        if (!row)
+            return 'embed';
+        return row.output_format === 'plain' ? 'plain' : 'embed';
+    }
+    /**
+     * Set the output format preference for a user (upsert).
+     */
+    setOutputFormat(userId, format) {
+        this.db.prepare(`
+            INSERT INTO user_preferences (user_id, output_format)
+            VALUES (?, ?)
+            ON CONFLICT(user_id)
+            DO UPDATE SET output_format = excluded.output_format,
+                          updated_at = datetime('now')
+        `).run(userId, format);
+    }
+    /**
+     * Get full preference record for a user
+     */
+    findByUserId(userId) {
+        const row = this.db.prepare('SELECT * FROM user_preferences WHERE user_id = ?').get(userId);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Map a DB row to UserPreferenceRecord
+     */
+    mapRow(row) {
+        return {
+            id: row.id,
+            userId: row.user_id,
+            outputFormat: row.output_format,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.UserPreferenceRepository = UserPreferenceRepository;

package/dist/events/interactionCreateHandler.js

@@ -4,37 +4,14 @@ exports.createInteractionCreateHandler = createInteractionCreateHandler;
 const discord_js_1 = require("discord.js");
 const i18n_1 = require("../utils/i18n");
 const logger_1 = require("../utils/logger");
+const discordButtonUtils_1 = require("../utils/discordButtonUtils");
 const templateUi_1 = require("../ui/templateUi");
 const autoAcceptUi_1 = require("../ui/autoAcceptUi");
+const outputUi_1 = require("../ui/outputUi");
 const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
 const projectListUi_1 = require("../ui/projectListUi");
 const modeService_1 = require("../services/modeService");
-/** Disable all buttons in message component rows. */
-function disableAllButtons(components) {
-    return components
-        .map((row) => {
-        const rowAny = row;
-        if (!Array.isArray(rowAny.components))
-            return null;
-        const nextRow = new discord_js_1.ActionRowBuilder();
-        const disabledButtons = rowAny.components
-            .map((component) => {
-            const componentType = component?.type ?? component?.data?.type;
-            if (componentType !== 2)
-                return null;
-            const payload = typeof component?.toJSON === 'function'
-                ? component.toJSON()
-                : component;
-            return discord_js_1.ButtonBuilder.from(payload).setDisabled(true);
-        })
-            .filter((button) => button !== null);
-        if (disabledButtons.length === 0)
-            return null;
-        nextRow.addComponents(...disabledButtons);
-        return nextRow;
-    })
-        .filter((row) => row !== null);
-}
+const sessionPickerUi_1 = require("../ui/sessionPickerUi");
 function createInteractionCreateHandler(deps) {
     return async (interaction) => {
         if (interaction.isButton()) {
@@ -52,9 +29,9 @@ function createInteractionCreateHandler(deps) {
                         }).catch(logger_1.logger.error);
                         return;
                     }
-                    const workspaceDirName = approvalAction.workspaceDirName ?? deps.bridge.lastActiveWorkspace;
-                    const detector = workspaceDirName
-                        ? deps.bridge.pool.getApprovalDetector(workspaceDirName)
+                    const projectName = approvalAction.projectName ?? deps.bridge.lastActiveWorkspace;
+                    const detector = projectName
+                        ? deps.bridge.pool.getApprovalDetector(projectName)
                         : undefined;
                     if (!detector) {
                         try {
@@ -90,7 +67,7 @@ function createInteractionCreateHandler(deps) {
                                 .setTimestamp();
                             await interaction.update({
                                 embeds: [updatedEmbed],
-                                components: disableAllButtons(interaction.message.components),
+                                components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
                             });
                         }
                         else {
@@ -122,7 +99,7 @@ function createInteractionCreateHandler(deps) {
                         }).catch(logger_1.logger.error);
                         return;
                     }
-                    const planWorkspaceDirName = planningAction.workspaceDirName ?? deps.bridge.lastActiveWorkspace;
+                    const planWorkspaceDirName = planningAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const planDetector = planWorkspaceDirName
                         ? deps.bridge.pool.getPlanningDetector(planWorkspaceDirName)
                         : undefined;
@@ -201,7 +178,7 @@ function createInteractionCreateHandler(deps) {
                             try {
                                 await interaction.update({
                                     embeds: [updatedEmbed],
-                                    components: disableAllButtons(interaction.message.components),
+                                    components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
                                 });
                             }
                             catch (interactionError) {
@@ -248,7 +225,7 @@ function createInteractionCreateHandler(deps) {
                         }).catch(logger_1.logger.error);
                         return;
                     }
-                    const errorWorkspaceDirName = errorPopupAction.workspaceDirName ?? deps.bridge.lastActiveWorkspace;
+                    const errorWorkspaceDirName = errorPopupAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const errorDetector = errorWorkspaceDirName
                         ? deps.bridge.pool.getErrorPopupDetector(errorWorkspaceDirName)
                         : undefined;
@@ -274,7 +251,7 @@ function createInteractionCreateHandler(deps) {
                             try {
                                 await interaction.update({
                                     embeds: [updatedEmbed],
-                                    components: disableAllButtons(interaction.message.components),
+                                    components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
                                 });
                             }
                             catch (interactionError) {
@@ -351,7 +328,7 @@ function createInteractionCreateHandler(deps) {
                             try {
                                 await interaction.update({
                                     embeds: [updatedEmbed],
-                                    components: disableAllButtons(interaction.message.components),
+                                    components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
                                 });
                             }
                             catch (interactionError) {
@@ -446,6 +423,20 @@ function createInteractionCreateHandler(deps) {
                     });
                     return;
                 }
+                if (interaction.customId === outputUi_1.OUTPUT_BTN_EMBED || interaction.customId === outputUi_1.OUTPUT_BTN_PLAIN) {
+                    if (deps.userPrefRepo) {
+                        await interaction.deferUpdate();
+                        const format = interaction.customId === outputUi_1.OUTPUT_BTN_PLAIN ? 'plain' : 'embed';
+                        deps.userPrefRepo.setOutputFormat(interaction.user.id, format);
+                        await (0, outputUi_1.sendOutputUI)({ editReply: async (data) => await interaction.editReply(data) }, format);
+                        const label = format === 'plain' ? 'Plain Text' : 'Embed';
+                        await interaction.followUp({
+                            content: `Output format changed to **${label}**.`,
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        });
+                    }
+                    return;
+                }
                 if (interaction.customId.startsWith(`${projectListUi_1.PROJECT_PAGE_PREFIX}:`)) {
                     const page = (0, projectListUi_1.parseProjectPageId)(interaction.customId);
                     if (!isNaN(page) && page >= 0) {
@@ -519,6 +510,32 @@ function createInteractionCreateHandler(deps) {
             }
             return;
         }
+        if (interaction.isStringSelectMenu() && (0, sessionPickerUi_1.isSessionSelectId)(interaction.customId)) {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                await interaction.deferUpdate();
+            }
+            catch (deferError) {
+                if (deferError?.code === 10062 || deferError?.code === 40060) {
+                    logger_1.logger.warn('[SessionSelect] deferUpdate expired. Skipping.');
+                    return;
+                }
+                logger_1.logger.error('[SessionSelect] deferUpdate failed:', deferError);
+                return;
+            }
+            try {
+                if (deps.joinHandler) {
+                    await deps.joinHandler.handleJoinSelect(interaction, deps.bridge);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('Session selection error:', error);
+            }
+            return;
+        }
         if (interaction.isStringSelectMenu() && (0, projectListUi_1.isProjectSelectId)(interaction.customId)) {
             if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
                 await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
@@ -547,7 +564,12 @@ function createInteractionCreateHandler(deps) {
             return;
         }
         try {
-            await commandInteraction.deferReply();
+            if (commandInteraction.commandName === 'logs') {
+                await commandInteraction.deferReply({ flags: discord_js_1.MessageFlags.Ephemeral });
+            }
+            else {
+                await commandInteraction.deferReply();
+            }
         }
         catch (deferError) {
             if (deferError?.code === 10062) {

package/dist/events/messageCreateHandler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMessageCreateHandler = createMessageCreateHandler;
 const discord_js_1 = require("discord.js");
 const messageParser_1 = require("../commands/messageParser");
+const plainTextFormatter_1 = require("../utils/plainTextFormatter");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const modeService_1 = require("../services/modeService");
 const imageHandler_1 = require("../utils/imageHandler");
@@ -17,6 +18,23 @@ function createMessageCreateHandler(deps) {
     const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
     const cleanupInboundImageAttachments = deps.cleanupInboundImageAttachments ?? imageHandler_1.cleanupInboundImageAttachments;
     const isImageAttachment = deps.isImageAttachment ?? imageHandler_1.isImageAttachment;
+    // Per-workspace prompt queue: serializes send→response cycles
+    const workspaceQueues = new Map();
+    const workspaceQueueDepths = new Map();
+    function enqueueForWorkspace(workspacePath, task) {
+        // .catch: ensure a prior rejection never stalls the chain
+        const current = (workspaceQueues.get(workspacePath) ?? Promise.resolve()).catch(() => { });
+        const next = current.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error('[WorkspaceQueue] task error:', err?.message || err);
+            }
+        });
+        workspaceQueues.set(workspacePath, next);
+        return next;
+    }
     return async (message) => {
         if (message.author.bot)
             return;
@@ -38,12 +56,12 @@ function createMessageCreateHandler(deps) {
             if (parsed.commandName === 'status') {
                 const activeNames = deps.bridge.pool.getActiveWorkspaceNames();
                 const currentMode = deps.modeService.getCurrentMode();
-                const embed = new discord_js_1.EmbedBuilder()
-                    .setTitle('🔧 Bot Status')
-                    .setColor(activeNames.length > 0 ? 0x00CC88 : 0x888888)
-                    .addFields({ name: 'CDP Connection', value: activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected', inline: true }, { name: 'Mode', value: modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode, inline: true }, { name: 'Auto Approve', value: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true })
-                    .setFooter({ text: '💡 Use the slash command /status for more detailed information' })
-                    .setTimestamp();
+                const statusFields = [
+                    { name: 'CDP Connection', value: activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected', inline: true },
+                    { name: 'Mode', value: modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode, inline: true },
+                    { name: 'Auto Approve', value: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true },
+                ];
+                let statusDescription = '';
                 if (activeNames.length > 0) {
                     const lines = activeNames.map((name) => {
                         const cdp = deps.bridge.pool.getConnected(name);
@@ -51,15 +69,33 @@ function createMessageCreateHandler(deps) {
                         const detectorActive = deps.bridge.pool.getApprovalDetector(name)?.isActive() ? ' [Detecting]' : '';
                         return `• **${name}** — Contexts: ${contexts}${detectorActive}`;
                     });
-                    embed.setDescription(`**Connected Projects:**\n${lines.join('\n')}`);
+                    statusDescription = `**Connected Projects:**\n${lines.join('\n')}`;
                 }
                 else {
-                    embed.setDescription('Send a message to auto-connect to a project.');
+                    statusDescription = 'Send a message to auto-connect to a project.';
+                }
+                const statusOutputFormat = deps.userPrefRepo?.getOutputFormat(message.author.id) ?? 'embed';
+                if (statusOutputFormat === 'plain') {
+                    const chunks = (0, plainTextFormatter_1.formatAsPlainText)({
+                        title: '🔧 Bot Status',
+                        description: statusDescription,
+                        fields: statusFields,
+                        footerText: 'Use the slash command /status for more detailed information',
+                    });
+                    await message.reply({ content: chunks[0] });
+                    return;
                 }
+                const embed = new discord_js_1.EmbedBuilder()
+                    .setTitle('🔧 Bot Status')
+                    .setColor(activeNames.length > 0 ? 0x00CC88 : 0x888888)
+                    .addFields(...statusFields)
+                    .setDescription(statusDescription)
+                    .setFooter({ text: '💡 Use the slash command /status for more detailed information' })
+                    .setTimestamp();
                 await message.reply({ embeds: [embed] });
                 return;
             }
-            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup'];
+            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup', 'join', 'mirror', 'output'];
             if (slashOnlyCommands.includes(parsed.commandName)) {
                 await message.reply({
                     content: `💡 Please use \`/${parsed.commandName}\` as a slash command.\nType \`/${parsed.commandName}\` in the Discord input field to see suggestions.`,
@@ -78,6 +114,7 @@ function createMessageCreateHandler(deps) {
                         chatSessionRepo: deps.chatSessionRepo,
                         channelManager: deps.channelManager,
                         titleGenerator: deps.titleGenerator,
+                        userPrefRepo: deps.userPrefRepo,
                     });
                 }
                 else {
@@ -98,58 +135,126 @@ function createMessageCreateHandler(deps) {
             const workspacePath = deps.wsHandler.getWorkspaceForChannel(message.channelId);
             try {
                 if (workspacePath) {
-                    try {
-                        const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
-                        const dirName = deps.bridge.pool.extractDirName(workspacePath);
-                        deps.bridge.lastActiveWorkspace = dirName;
-                        deps.bridge.lastActiveChannel = message.channel;
-                        registerApprovalWorkspaceChannel(deps.bridge, dirName, message.channel);
-                        ensureApprovalDetector(deps.bridge, cdp, dirName, deps.client);
-                        ensureErrorPopupDetector(deps.bridge, cdp, dirName, deps.client);
-                        ensurePlanningDetector(deps.bridge, cdp, dirName, deps.client);
-                        const session = deps.chatSessionRepo.findByChannelId(message.channelId);
-                        if (session?.displayName) {
-                            registerApprovalSessionChannel(deps.bridge, dirName, session.displayName, message.channel);
+                    const projectLabel = deps.bridge.pool.extractProjectName(workspacePath);
+                    // Track queue depth for hourglass reactions
+                    const currentDepth = workspaceQueueDepths.get(workspacePath) ?? 0;
+                    workspaceQueueDepths.set(workspacePath, currentDepth + 1);
+                    const newDepth = currentDepth + 1;
+                    if (currentDepth > 0) {
+                        logger_1.logger.info(`[Queue:${projectLabel}] Enqueued (depth: ${newDepth}, channel: ${message.channelId})`);
+                        await message.react('⏳').catch(() => { });
+                    }
+                    else {
+                        logger_1.logger.info(`[Queue:${projectLabel}] Processing immediately (depth: ${newDepth}, channel: ${message.channelId})`);
+                    }
+                    const queueStartTime = Date.now();
+                    await enqueueForWorkspace(workspacePath, async () => {
+                        const waitMs = Date.now() - queueStartTime;
+                        if (waitMs > 100) {
+                            logger_1.logger.info(`[Queue:${projectLabel}] Task started after ${Math.round(waitMs / 1000)}s wait (channel: ${message.channelId})`);
                         }
-                        if (session?.isRenamed && session.displayName) {
-                            const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
-                            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(() => { });
-                                return;
-                            }
+                        // Remove hourglass when task starts processing
+                        const botId = message.client.user?.id;
+                        if (botId) {
+                            await message.reactions.resolve('⏳')?.users.remove(botId).catch(() => { });
                         }
-                        else if (session && !session.isRenamed) {
-                            try {
-                                const chatResult = await deps.chatSessionService.startNewChat(cdp);
-                                if (!chatResult.ok) {
-                                    logger_1.logger.warn('[MessageCreate] Failed to start new chat in Antigravity:', chatResult.error);
+                        try {
+                            const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
+                            const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+                            deps.bridge.lastActiveWorkspace = projectName;
+                            deps.bridge.lastActiveChannel = message.channel;
+                            registerApprovalWorkspaceChannel(deps.bridge, projectName, message.channel);
+                            ensureApprovalDetector(deps.bridge, cdp, projectName, deps.client);
+                            ensureErrorPopupDetector(deps.bridge, cdp, projectName, deps.client);
+                            ensurePlanningDetector(deps.bridge, cdp, projectName, deps.client);
+                            const session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            if (session?.displayName) {
+                                registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, message.channel);
+                            }
+                            if (session?.isRenamed && session.displayName) {
+                                const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
+                                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(() => { });
+                                    return;
+                                }
+                            }
+                            else if (session && !session.isRenamed) {
+                                try {
+                                    const chatResult = await deps.chatSessionService.startNewChat(cdp);
+                                    if (!chatResult.ok) {
+                                        logger_1.logger.warn('[MessageCreate] Failed to start new chat in Antigravity:', chatResult.error);
+                                        message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                                    }
+                                }
+                                catch (err) {
+                                    logger_1.logger.error('[MessageCreate] startNewChat error:', err);
                                     message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
                                 }
                             }
-                            catch (err) {
-                                logger_1.logger.error('[MessageCreate] startNewChat error:', err);
-                                message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                            await deps.autoRenameChannel(message, deps.chatSessionRepo, deps.titleGenerator, deps.channelManager, cdp);
+                            // Re-register session channel after autoRenameChannel sets displayName
+                            const updatedSession = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            if (updatedSession?.displayName) {
+                                registerApprovalSessionChannel(deps.bridge, projectName, updatedSession.displayName, message.channel);
+                            }
+                            // Register echo hash so UserMessageDetector skips this message
+                            const userMsgDetector = deps.bridge.pool.getUserMessageDetector?.(projectName);
+                            if (userMsgDetector) {
+                                userMsgDetector.addEchoHash(promptText);
                             }
+                            // Wait for full response cycle (onComplete/onTimeout) before releasing the queue.
+                            // Safety timeout (360s) prevents permanent queue deadlock if onFullCompletion
+                            // is never called due to a bug.
+                            const QUEUE_SAFETY_TIMEOUT_MS = 360_000;
+                            const promptStartTime = Date.now();
+                            await new Promise((resolve) => {
+                                const safetyTimer = setTimeout(() => {
+                                    logger_1.logger.warn(`[Queue:${projectName}] Safety timeout — releasing queue after 360s ` +
+                                        `(channel: ${message.channelId})`);
+                                    resolve();
+                                }, QUEUE_SAFETY_TIMEOUT_MS);
+                                let settled = false;
+                                const settle = () => {
+                                    if (settled)
+                                        return;
+                                    settled = true;
+                                    clearTimeout(safetyTimer);
+                                    const elapsed = Math.round((Date.now() - promptStartTime) / 1000);
+                                    logger_1.logger.info(`[Queue:${projectName}] Prompt completed in ${elapsed}s ` +
+                                        `(channel: ${message.channelId})`);
+                                    resolve();
+                                };
+                                deps.sendPromptToAntigravity(deps.bridge, message, promptText, cdp, deps.modeService, deps.modelService, inboundImages, {
+                                    chatSessionService: deps.chatSessionService,
+                                    chatSessionRepo: deps.chatSessionRepo,
+                                    channelManager: deps.channelManager,
+                                    titleGenerator: deps.titleGenerator,
+                                    userPrefRepo: deps.userPrefRepo,
+                                    onFullCompletion: settle,
+                                }).catch((err) => {
+                                    // sendPromptToAntigravity rejected before onFullCompletion fired
+                                    // (e.g. setup code threw before top-level try/catch).
+                                    // Release the queue immediately instead of waiting for safety timeout.
+                                    logger_1.logger.error(`[Queue:${projectName}] sendPromptToAntigravity rejected early ` +
+                                        `(channel: ${message.channelId}):`, err?.message || err);
+                                    settle();
+                                });
+                            });
                         }
-                        await deps.autoRenameChannel(message, deps.chatSessionRepo, deps.titleGenerator, deps.channelManager, cdp);
-                        // Re-register session channel after autoRenameChannel sets displayName
-                        const updatedSession = deps.chatSessionRepo.findByChannelId(message.channelId);
-                        if (updatedSession?.displayName) {
-                            registerApprovalSessionChannel(deps.bridge, dirName, updatedSession.displayName, message.channel);
+                        catch (e) {
+                            logger_1.logger.error(`[Queue:${projectLabel}] Task failed (channel: ${message.channelId}):`, e.message);
+                            await message.reply(`Failed to connect to workspace: ${e.message}`);
                         }
-                        await deps.sendPromptToAntigravity(deps.bridge, message, promptText, cdp, deps.modeService, deps.modelService, inboundImages, {
-                            chatSessionService: deps.chatSessionService,
-                            chatSessionRepo: deps.chatSessionRepo,
-                            channelManager: deps.channelManager,
-                            titleGenerator: deps.titleGenerator,
-                        });
-                    }
-                    catch (e) {
-                        await message.reply(`Failed to connect to workspace: ${e.message}`);
-                        return;
-                    }
+                        finally {
+                            const remainingDepth = (workspaceQueueDepths.get(workspacePath) ?? 1) - 1;
+                            workspaceQueueDepths.set(workspacePath, remainingDepth);
+                            if (remainingDepth > 0) {
+                                logger_1.logger.info(`[Queue:${projectLabel}] Task done, ${remainingDepth} remaining`);
+                            }
+                        }
+                    });
                 }
                 else {
                     await message.reply('No project is configured for this channel. Please create or select one with `/project`.');

package/dist/services/antigravityLauncher.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAntigravityRunning = ensureAntigravityRunning;
 const logger_1 = require("../utils/logger");
 const cdpPorts_1 = require("../utils/cdpPorts");
+const pathUtils_1 = require("../utils/pathUtils");
 const http = __importStar(require("http"));
 /**
  * Check if CDP responds on the specified port.
@@ -69,10 +70,10 @@ function checkPort(port) {
  * Called during Bot initialization.
  */
 async function ensureAntigravityRunning() {
-    logger_1.logger.info('[AntigravityLauncher] Checking CDP ports...');
+    logger_1.logger.debug('[AntigravityLauncher] Checking CDP ports...');
     for (const port of cdpPorts_1.CDP_PORTS) {
         if (await checkPort(port)) {
-            logger_1.logger.info(`[AntigravityLauncher] OK — Port ${port} responding`);
+            logger_1.logger.debug(`[AntigravityLauncher] OK — Port ${port} responding`);
             return;
         }
     }
@@ -83,7 +84,7 @@ async function ensureAntigravityRunning() {
     logger_1.logger.warn('  Please run AntigravityDebug.command before starting the Bot');
     logger_1.logger.warn('');
     logger_1.logger.warn('  Or manually:');
-    logger_1.logger.warn('    open -a Antigravity --args --remote-debugging-port=9222');
+    logger_1.logger.warn(`    ${(0, pathUtils_1.getAntigravityCdpHint)(9222)}`);
     logger_1.logger.warn('='.repeat(70));
     logger_1.logger.warn('');
 }

package/dist/services/approvalDetector.js

@@ -206,6 +206,7 @@ class ApprovalDetector {
     cdpService;
     pollIntervalMs;
     onApprovalRequired;
+    onResolved;
     pollTimer = null;
     isRunning = false;
     /** Key of the last detected button info (for duplicate notification prevention) */
@@ -216,6 +217,7 @@ class ApprovalDetector {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 1500;
         this.onApprovalRequired = options.onApprovalRequired;
+        this.onResolved = options.onResolved;
     }
     /**
      * Start monitoring.
@@ -286,8 +288,12 @@ class ApprovalDetector {
             }
             else {
                 // Reset when buttons disappear (prepare for next approval detection)
+                const wasDetected = this.lastDetectedKey !== null;
                 this.lastDetectedKey = null;
                 this.lastDetectedInfo = null;
+                if (wasDetected && this.onResolved) {
+                    this.onResolved();
+                }
             }
         }
         catch (error) {