lazy-gravity 0.10.0 → 0.12.0

package/dist/commands/chatCommandHandler.js

@@ -1,40 +1,8 @@
 "use strict";
-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.ChatCommandHandler = void 0;
 const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
 const discord_js_1 = require("discord.js");
 /**
  * Handler for chat session related commands
@@ -111,9 +79,7 @@ class ChatCommandHandler {
         if (!newChatResult.ok) {
             // Log but don't fail the command, as the channel still needs to be created
             // and the user might just have to click it manually if the IDE state is strange.
-            Promise.resolve().then(() => __importStar(require('../utils/logger'))).then(({ logger }) => {
-                logger.warn(`[/new] Could not start new chat in IDE automatically: ${newChatResult.error}`);
-            });
+            logger_1.logger.warn(`[/new] Could not start new chat in IDE automatically: ${newChatResult.error}`);
         }
         const customNameRaw = interaction.options.getString('name');
         let safeCustomName = null;
@@ -156,9 +122,7 @@ class ChatCommandHandler {
             if (workspaceCdp) {
                 const renameResult = await this.chatSessionService.renameCurrentChatInUI(workspaceCdp, safeCustomName);
                 if (!renameResult.ok) {
-                    Promise.resolve().then(() => __importStar(require('../utils/logger'))).then(({ logger }) => {
-                        logger.warn(`[/new] Could not rename chat in IDE automatically: ${renameResult.error}`);
-                    });
+                    logger_1.logger.warn(`[/new] Could not rename chat in IDE automatically: ${renameResult.error}`);
                 }
             }
         }
@@ -185,8 +149,14 @@ class ChatCommandHandler {
             const embed = new discord_js_1.EmbedBuilder()
                 .setTitle((0, i18n_1.t)('💬 Chat Session Info'))
                 .setColor(info.hasActiveChat ? 0x00CC88 : 0x888888)
-                .addFields({ name: (0, i18n_1.t)('Title'), value: info.title, inline: true }, { name: (0, i18n_1.t)('Status'), value: info.hasActiveChat ? (0, i18n_1.t)('🟢 Active') : (0, i18n_1.t)('⚪ Inactive'), inline: true })
-                .setDescription((0, i18n_1.t)('※ Non-session channel.\nUse `/project` to create a project first.'))
+                .addFields({ name: (0, i18n_1.t)('Title'), value: info.title, inline: true }, { name: (0, i18n_1.t)('Status'), value: info.hasActiveChat ? (0, i18n_1.t)('🟢 Active') : (0, i18n_1.t)('⚪ Inactive'), inline: true });
+            const channel = await interaction.client.channels.fetch(interaction.channelId).catch(() => null);
+            const categoryId = channel?.parentId;
+            const isProjectChannel = categoryId ? !!this.bindingRepo.findByChannelId(categoryId) : false;
+            const desc = isProjectChannel
+                ? (0, i18n_1.t)('※ No active session is bound to this channel.\n\n💡 **Tip**: If you recently deleted a session in the IDE, this channel was automatically unbound. Send a prompt or use `/new` to start a fresh chat.')
+                : (0, i18n_1.t)('※ Non-session channel.\nUse `/project` to create a project first.');
+            embed.setDescription(desc)
                 .setTimestamp();
             await interaction.editReply({ embeds: [embed] });
             return;

package/dist/commands/registerSlashCommands.js

@@ -168,6 +168,66 @@ const openCommand = new discord_js_1.SlashCommandBuilder()
     .setName('filepath')
     .setDescription((0, i18n_1.t)('Absolute or relative path to the file'))
     .setRequired(true));
+/** /heartbeat command definition */
+const heartbeatCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('heartbeat')
+    .setDescription((0, i18n_1.t)('Configure periodic bot heartbeat notifications'))
+    .addSubcommand((sub) => sub
+    .setName('on')
+    .setDescription((0, i18n_1.t)('Enable periodic heartbeats'))
+    .addStringOption((option) => option
+    .setName('interval')
+    .setDescription((0, i18n_1.t)('Interval (e.g., 1d, 1h, 30m - unit required)'))
+    .setRequired(false))
+    .addChannelOption((option) => option
+    .setName('channel')
+    .setDescription((0, i18n_1.t)('Target channel for heartbeat (defaults to current)'))
+    .addChannelTypes(discord_js_1.ChannelType.GuildText, discord_js_1.ChannelType.GuildAnnouncement)
+    .setRequired(false)))
+    .addSubcommand((sub) => sub
+    .setName('off')
+    .setDescription((0, i18n_1.t)('Disable periodic heartbeats')))
+    .addSubcommand((sub) => sub
+    .setName('status')
+    .setDescription((0, i18n_1.t)('Display current heartbeat config and status')));
+/** /schedule command definition */
+const scheduleCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('schedule')
+    .setDescription((0, i18n_1.t)('Manage scheduled tasks'))
+    .addSubcommand((sub) => sub
+    .setName('list')
+    .setDescription((0, i18n_1.t)('Show all scheduled tasks with next-run times')))
+    .addSubcommand((sub) => sub
+    .setName('add')
+    .setDescription((0, i18n_1.t)('Register a recurring task'))
+    .addStringOption((option) => option
+    .setName('cron')
+    .setDescription((0, i18n_1.t)('Cron expression (e.g. "0 * * * *")'))
+    .setRequired(true))
+    .addStringOption((option) => option
+    .setName('prompt')
+    .setDescription((0, i18n_1.t)('Prompt content to execute'))
+    .setRequired(true)))
+    .addSubcommand((sub) => sub
+    .setName('remove')
+    .setDescription((0, i18n_1.t)('Delete a scheduled task'))
+    .addIntegerOption((option) => option
+    .setName('id')
+    .setDescription((0, i18n_1.t)('ID of the task to delete'))
+    .setRequired(true)))
+    .addSubcommand((sub) => sub
+    .setName('clear')
+    .setDescription((0, i18n_1.t)('Remove all scheduled tasks and reset task IDs')))
+    .addSubcommand((sub) => sub
+    .setName('backup')
+    .setDescription((0, i18n_1.t)('Export all scheduled tasks as a JSON file attachment')))
+    .addSubcommand((sub) => sub
+    .setName('restore')
+    .setDescription((0, i18n_1.t)('Restore scheduled tasks from a JSON file attachment'))
+    .addAttachmentOption((option) => option
+    .setName('file')
+    .setDescription((0, i18n_1.t)('The schedules_backup.json file to import'))
+    .setRequired(true)));
 /** Array of commands to register */
 exports.slashCommands = [
     helpCommand,
@@ -191,6 +251,8 @@ exports.slashCommands = [
     logsCommand,
     artifactsCommand,
     openCommand,
+    heartbeatCommand,
+    scheduleCommand,
 ];
 /**
  * Register slash commands with Discord

package/dist/database/scheduleRepository.js

@@ -11,9 +11,6 @@ class ScheduleRepository {
         this.db = db;
         this.initialize();
     }
-    /**
-     * Initialize table (create if not exists)
-     */
     initialize() {
         this.db.exec(`
             CREATE TABLE IF NOT EXISTS schedules (
@@ -21,25 +18,33 @@ class ScheduleRepository {
                 cron_expression TEXT NOT NULL,
                 prompt TEXT NOT NULL,
                 workspace_path TEXT NOT NULL,
+                channel_id TEXT,
                 enabled INTEGER NOT NULL DEFAULT 1,
                 created_at TEXT NOT NULL DEFAULT (datetime('now'))
             )
         `);
+        // Perform schema migration if channel_id doesn't exist (fallback for old databases)
+        const tableInfo = this.db.pragma("table_info(schedules)");
+        const hasChannelId = tableInfo.some((col) => col.name === 'channel_id');
+        if (!hasChannelId) {
+            this.db.exec('ALTER TABLE schedules ADD COLUMN channel_id TEXT');
+        }
     }
     /**
      * Create a new schedule
      */
     create(input) {
         const stmt = this.db.prepare(`
-            INSERT INTO schedules (cron_expression, prompt, workspace_path, enabled)
-            VALUES (?, ?, ?, ?)
+            INSERT INTO schedules (cron_expression, prompt, workspace_path, channel_id, enabled)
+            VALUES (?, ?, ?, ?, ?)
         `);
-        const result = stmt.run(input.cronExpression, input.prompt, input.workspacePath, input.enabled ? 1 : 0);
+        const result = stmt.run(input.cronExpression, input.prompt, input.workspacePath, input.channelId || '', input.enabled ? 1 : 0);
         return {
             id: result.lastInsertRowid,
             cronExpression: input.cronExpression,
             prompt: input.prompt,
             workspacePath: input.workspacePath,
+            channelId: input.channelId,
             enabled: input.enabled,
         };
     }
@@ -73,6 +78,40 @@ class ScheduleRepository {
         const result = this.db.prepare('DELETE FROM schedules WHERE id = ?').run(id);
         return result.changes > 0;
     }
+    /**
+     * Clear all schedules and reset the autoincrement ID back to 0
+     */
+    reset() {
+        this.db.transaction(() => {
+            this.db.exec('DELETE FROM schedules');
+            this.db.exec("DELETE FROM sqlite_sequence WHERE name = 'schedules'");
+        })();
+    }
+    /**
+     * Bulk restore schedules. Clears the table and inserts all provided records.
+     */
+    bulkRestore(records) {
+        const result = [];
+        this.db.transaction(() => {
+            this.reset();
+            const stmt = this.db.prepare(`
+                INSERT INTO schedules (cron_expression, prompt, workspace_path, channel_id, enabled)
+                VALUES (?, ?, ?, ?, ?)
+            `);
+            for (const record of records) {
+                const insertResult = stmt.run(record.cronExpression, record.prompt, record.workspacePath, record.channelId || '', record.enabled ? 1 : 0);
+                result.push({
+                    id: insertResult.lastInsertRowid,
+                    cronExpression: record.cronExpression,
+                    prompt: record.prompt,
+                    workspacePath: record.workspacePath,
+                    channelId: record.channelId,
+                    enabled: record.enabled,
+                });
+            }
+        })();
+        return result;
+    }
     /**
      * Partially update a schedule
      */
@@ -91,6 +130,10 @@ class ScheduleRepository {
             sets.push('workspace_path = ?');
             values.push(input.workspacePath);
         }
+        if (input.channelId !== undefined) {
+            sets.push('channel_id = ?');
+            values.push(input.channelId);
+        }
         if (input.enabled !== undefined) {
             sets.push('enabled = ?');
             values.push(input.enabled ? 1 : 0);
@@ -111,6 +154,7 @@ class ScheduleRepository {
             cronExpression: row.cron_expression,
             prompt: row.prompt,
             workspacePath: row.workspace_path,
+            channelId: row.channel_id || undefined,
             enabled: row.enabled === 1,
             createdAt: row.created_at,
         };

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");
@@ -110,6 +112,10 @@ function createInteractionCreateHandler(deps) {
         return { ok: true };
     };
     return async (interaction) => {
+        const isHeartbeatCommand = 'commandName' in interaction && interaction.commandName === 'heartbeat';
+        if (deps.heartbeatService && deps.config.allowedUserIds.includes(interaction.user.id) && !isHeartbeatCommand) {
+            deps.heartbeatService.recordActivity();
+        }
         if (interaction.isAutocomplete()) {
             if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
                 await interaction.respond([]).catch(logger_1.logger.error);
@@ -226,6 +232,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 +892,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 +943,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 +1004,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 +1025,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 +1348,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 +1380,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);
@@ -1317,7 +1452,7 @@ function createInteractionCreateHandler(deps) {
             throw deferError;
         }
         try {
-            await deps.handleSlashInteraction(commandInteraction, deps.slashCommandHandler, deps.bridge, deps.wsHandler, deps.chatHandler, deps.cleanupHandler, deps.modeService, deps.modelService, deps.bridge.autoAccept, deps.client, deps.accountPrefRepo, deps.channelPrefRepo, deps.antigravityAccounts, deps.chatSessionRepo, deps.scheduleService);
+            await deps.handleSlashInteraction(commandInteraction, deps.slashCommandHandler, deps.bridge, deps.wsHandler, deps.chatHandler, deps.cleanupHandler, deps.modeService, deps.modelService, deps.bridge.autoAccept, deps.client, deps.accountPrefRepo, deps.channelPrefRepo, deps.antigravityAccounts, deps.chatSessionRepo, deps.scheduleService, deps.heartbeatService);
         }
         catch (error) {
             logger_1.logger.error(`[SlashCommand] command=${commandInteraction.commandName} channel=${commandInteraction.channelId} ` +

package/dist/events/messageCreateHandler.js

@@ -10,7 +10,9 @@ const modeService_1 = require("../services/modeService");
 const imageHandler_1 = require("../utils/imageHandler");
 const accountUtils_1 = require("../utils/accountUtils");
 const logger_1 = require("../utils/logger");
+const workspaceQueue_1 = require("../bot/workspaceQueue");
 function createMessageCreateHandler(deps) {
+    const workspaceQueue = deps.workspaceQueue ?? new workspaceQueue_1.WorkspaceQueue();
     const getCurrentCdp = deps.getCurrentCdp ?? cdpBridgeManager_1.getCurrentCdp;
     const ensureApprovalDetector = deps.ensureApprovalDetector ?? cdpBridgeManager_1.ensureApprovalDetector;
     const ensureErrorPopupDetector = deps.ensureErrorPopupDetector ?? cdpBridgeManager_1.ensureErrorPopupDetector;
@@ -31,29 +33,15 @@ function createMessageCreateHandler(deps) {
         return match ? match.cdpPort : null;
     };
     const getSessionAccountName = (channelId) => deps.chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null;
-    // 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;
         if (!deps.config.allowedUserIds.includes(message.author.id)) {
             return;
         }
+        if (deps.heartbeatService) {
+            deps.heartbeatService.recordActivity();
+        }
         const parsed = (0, messageParser_1.parseMessageContent)(message.content);
         if (parsed.isCommand && parsed.commandName) {
             if (parsed.commandName === 'autoaccept') {
@@ -160,7 +148,7 @@ function createMessageCreateHandler(deps) {
                 await message.reply(`✅ Switched session account to **${requested}**.`).catch(() => { });
                 return;
             }
-            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup', 'join', 'mirror', 'output'];
+            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup', 'join', 'mirror', 'output', 'heartbeat'];
             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.`,
@@ -225,7 +213,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\`\`\``;
@@ -252,9 +243,8 @@ function createMessageCreateHandler(deps) {
                 if (workspacePath) {
                     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;
+                    const currentDepth = workspaceQueue.getDepth(workspacePath);
+                    const newDepth = workspaceQueue.incrementDepth(workspacePath);
                     if (currentDepth > 0) {
                         logger_1.logger.info(`[Queue:${projectLabel}] Enqueued (depth: ${newDepth}, channel: ${message.channelId})`);
                         await message.react('⏳').catch(() => { });
@@ -263,7 +253,7 @@ function createMessageCreateHandler(deps) {
                         logger_1.logger.info(`[Queue:${projectLabel}] Processing immediately (depth: ${newDepth}, channel: ${message.channelId})`);
                     }
                     const queueStartTime = Date.now();
-                    await enqueueForWorkspace(workspacePath, async () => {
+                    await workspaceQueue.enqueue(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})`);
@@ -349,9 +339,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;
                                     }
                                 }
@@ -427,8 +424,7 @@ function createMessageCreateHandler(deps) {
                             await message.reply(`Failed to connect to workspace: ${e.message}`);
                         }
                         finally {
-                            const remainingDepth = (workspaceQueueDepths.get(workspacePath) ?? 1) - 1;
-                            workspaceQueueDepths.set(workspacePath, remainingDepth);
+                            const remainingDepth = workspaceQueue.decrementDepth(workspacePath);
                             if (remainingDepth > 0) {
                                 logger_1.logger.info(`[Queue:${projectLabel}] Task done, ${remainingDepth} remaining`);
                             }