lazy-gravity 0.11.0 → 0.12.0

package/README.md

@@ -90,12 +90,19 @@ Just type in any bound channel:
 - `📝 /template list` — Display registered templates with execute buttons
 - `📝 /template add <name> <prompt>` — Register a new prompt template
 - `📝 /template delete <name>` — Delete a template
+- `📅 /schedule list` — Show all scheduled tasks with next localized run times
+- `📅 /schedule add <cron> <prompt>` — Register a recurring task for the current channel's bound project
+- `📅 /schedule remove <id>` — Delete a scheduled task by ID
+- `📅 /schedule clear` — Remove all scheduled tasks and reset the task ID counter
+- `📅 /schedule backup` — Export all scheduled tasks as a JSON file attachment
+- `📅 /schedule restore <file>` — Restore scheduled tasks from a JSON file attachment
 - `🔗 /join` — Join an existing Antigravity session (shows up to 20 recent sessions)
 - `🔗 /mirror` — Toggle PC→Discord message mirroring for the current session
 - `🛑 /stop` — Force-stop a running Antigravity task
 - `🛑 /shutdown` — Shut down the IDE while keeping the active CDP project connections and session bindings
 - `📸 /screenshot` — Capture and send Antigravity's current screen
 - `🔧 /status` — Show bot connection status, current mode, and active project
+- `💓 /heartbeat [on|off|status]` — Configure periodic bot heartbeat notifications
 - `✅ /autoaccept [on|off|status]` — Toggle auto-approval of file edit dialogs
 - `📝 /output [embed|plain]` — Toggle output format between Embed and Plain Text (plain text is easier to copy on mobile)
 - `📋 /logs [lines] [level]` — View recent bot logs (ephemeral)

package/dist/bot/index.js

@@ -62,6 +62,10 @@ const workspaceBindingRepository_1 = require("../database/workspaceBindingReposi
 const channelPreferenceRepository_1 = require("../database/channelPreferenceRepository");
 const chatSessionRepository_1 = require("../database/chatSessionRepository");
 const artifactThreadRepository_1 = require("../database/artifactThreadRepository");
+const scheduleRepository_1 = require("../database/scheduleRepository");
+const scheduleService_1 = require("../services/scheduleService");
+const cron_parser_1 = __importDefault(require("cron-parser"));
+const workspaceQueue_1 = require("./workspaceQueue");
 const workspaceService_1 = require("../services/workspaceService");
 const workspaceCommandHandler_1 = require("../commands/workspaceCommandHandler");
 const chatCommandHandler_1 = require("../commands/chatCommandHandler");
@@ -108,6 +112,7 @@ const buttonHandler_1 = require("../handlers/buttonHandler");
 const selectHandler_1 = require("../handlers/selectHandler");
 const approvalButtonAction_1 = require("../handlers/approvalButtonAction");
 const planningButtonAction_1 = require("../handlers/planningButtonAction");
+const heartbeatService_1 = require("../services/heartbeatService");
 const errorPopupButtonAction_1 = require("../handlers/errorPopupButtonAction");
 const runCommandButtonAction_1 = require("../handlers/runCommandButtonAction");
 const modelButtonAction_1 = require("../handlers/modelButtonAction");
@@ -1100,9 +1105,13 @@ const startBot = async (cliLogLevel) => {
     const workspaceBindingRepo = new workspaceBindingRepository_1.WorkspaceBindingRepository(db);
     const chatSessionRepo = new chatSessionRepository_1.ChatSessionRepository(db);
     const artifactThreadRepo = new artifactThreadRepository_1.ArtifactThreadRepository(db);
+    const scheduleRepo = new scheduleRepository_1.ScheduleRepository(db);
+    const scheduleService = new scheduleService_1.ScheduleService(scheduleRepo);
+    const workspaceQueue = new workspaceQueue_1.WorkspaceQueue();
     const artifactService = new artifactService_1.ArtifactService();
     const workspaceService = new workspaceService_1.WorkspaceService(config.workspaceBaseDir);
     const channelManager = new channelManager_1.ChannelManager();
+    const heartbeatService = new heartbeatService_1.HeartbeatService();
     // Auto-launch Antigravity with CDP port if not already running
     await (0, antigravityLauncher_1.ensureAntigravityRunning)();
     // Initialize CDP bridge (lazy connection: pool creation only)
@@ -1217,6 +1226,8 @@ const startBot = async (cliLogLevel) => {
             }));
             client.once(discord_js_1.Events.ClientReady, async (readyClient) => {
                 logger_1.logger.info(`Ready! Logged in as ${readyClient.user.tag} | extractionMode=${config.extractionMode}`);
+                heartbeatService.init(readyClient, bridge);
+                heartbeatService.start();
                 try {
                     await (0, registerSlashCommands_1.registerSlashCommands)(discordToken, discordClientId, config.guildId);
                 }
@@ -1257,6 +1268,74 @@ const startBot = async (cliLogLevel) => {
                 catch (error) {
                     logger_1.logger.warn('Failed to send startup dashboard embed:', error);
                 }
+                // Restore scheduled tasks
+                const scheduleJobCallback = async (schedule) => {
+                    logger_1.logger.info(`[Schedule] Trigger callback running for task ${schedule.id}. Workspace: ${schedule.workspacePath}, promptLength: ${schedule.prompt.length}`);
+                    try {
+                        let channelId = schedule.channelId;
+                        const isWindows = process.platform === 'win32';
+                        const bindings = workspaceBindingRepo.findAll().filter(b => {
+                            const absPath = workspaceService.getWorkspacePath(b.workspacePath);
+                            return isWindows
+                                ? absPath.toLowerCase() === schedule.workspacePath.toLowerCase()
+                                : absPath === schedule.workspacePath;
+                        });
+                        if (!channelId || !bindings.some(b => b.channelId === channelId)) {
+                            channelId = bindings[0]?.channelId;
+                        }
+                        if (!channelId) {
+                            logger_1.logger.warn(`[Schedule] No channel bound to workspace ${schedule.workspacePath}. Skipping task ${schedule.id}.`);
+                            return;
+                        }
+                        const channel = await readyClient.channels.fetch(channelId).catch(() => null);
+                        if (channel && channel.isTextBased() && 'send' in channel) {
+                            logger_1.logger.info(`[Schedule] Sending trigger notification to channel ${channelId} for task ${schedule.id}`);
+                            const message = await channel.send({
+                                content: '⏰ **Scheduled Task Triggered**',
+                                allowedMentions: { parse: [] }
+                            });
+                            const projectLabel = bridge.pool.extractProjectName(schedule.workspacePath);
+                            workspaceQueue.incrementDepth(schedule.workspacePath);
+                            await workspaceQueue.enqueue(schedule.workspacePath, async () => {
+                                try {
+                                    logger_1.logger.info(`[Schedule] Dispatching prompt to promptDispatcher for task ${schedule.id}`);
+                                    const preferredAccount = bridge.pool.getPreferredAccountForWorkspace(schedule.workspacePath)
+                                        || (config.antigravityAccounts?.[0]?.name ?? 'default');
+                                    const cdp = await bridge.pool.getOrConnect(schedule.workspacePath, { name: preferredAccount });
+                                    await promptDispatcher.send({
+                                        message: message,
+                                        prompt: schedule.prompt,
+                                        cdp,
+                                        inboundImages: [],
+                                        options: {
+                                            chatSessionService,
+                                            chatSessionRepo,
+                                            channelManager,
+                                            titleGenerator,
+                                            userPrefRepo,
+                                            artifactService,
+                                            extractionMode: config.extractionMode,
+                                        },
+                                    });
+                                }
+                                finally {
+                                    const remainingDepth = workspaceQueue.decrementDepth(schedule.workspacePath);
+                                    if (remainingDepth > 0) {
+                                        logger_1.logger.info(`[Queue:${projectLabel}] Task done, ${remainingDepth} remaining`);
+                                    }
+                                }
+                            });
+                        }
+                        else {
+                            logger_1.logger.warn(`[Schedule] Channel ${channelId} not found or not text-based for task ${schedule.id}.`);
+                        }
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`[Schedule] Failed to execute task ${schedule.id}:`, error);
+                    }
+                };
+                const restoredCount = scheduleService.restoreAll(scheduleJobCallback);
+                logger_1.logger.info(`[Schedule] Restored ${restoredCount} scheduled tasks.`);
             });
             // [Discord Interactions API] Slash command interaction handler
             client.on(discord_js_1.Events.InteractionCreate, (0, interactionCreateHandler_1.createInteractionCreateHandler)({
@@ -1290,7 +1369,9 @@ const startBot = async (cliLogLevel) => {
                 channelManager,
                 titleGenerator,
                 antigravityAccounts: config.antigravityAccounts,
-                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, scheduleServiceArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, artifactService, scheduleServiceArg),
+                heartbeatService,
+                scheduleService,
+                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, scheduleServiceArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepoArg, artifactService, scheduleServiceArg, heartbeatService),
                 handleTemplateUse: async (interaction, templateId) => {
                     const template = templateRepo.findById(templateId);
                     if (!template) {
@@ -1412,6 +1493,8 @@ const startBot = async (cliLogLevel) => {
                 accountPrefRepo,
                 channelPrefRepo,
                 antigravityAccounts: config.antigravityAccounts,
+                heartbeatService,
+                workspaceQueue,
             }));
             await client.login(discordToken);
         } // end: else (credentials present)
@@ -1682,10 +1765,22 @@ async function autoRenameChannel(message, chatSessionRepo, titleGenerator, chann
         logger_1.logger.error('[AutoRename] Rename failed:', err);
     }
 }
+/**
+ * Utility to parse a cron expression and format the next run time.
+ */
+function formatNextRunTime(cronExpression) {
+    try {
+        const interval = cron_parser_1.default.parse(cronExpression);
+        return interval.next().toDate().toLocaleString();
+    }
+    catch (err) {
+        return 'Invalid Cron';
+    }
+}
 /**
  * Handle Discord Interactions API slash commands
  */
-async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, chatSessionService, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepo, channelPrefRepo, antigravityAccounts = [{ name: 'default', cdpPort: 9222 }], chatSessionRepo, artifactService, scheduleService) {
+async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, chatSessionService, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepo, channelPrefRepo, antigravityAccounts = [{ name: 'default', cdpPort: 9222 }], chatSessionRepo, artifactService, scheduleService, heartbeatService) {
     const commandName = interaction.commandName;
     const getAccountPort = (accountName) => {
         const match = antigravityAccounts.find((account) => account.name === accountName);
@@ -2248,6 +2343,244 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             });
             break;
         }
+        case 'heartbeat': {
+            const subcommand = interaction.options.getSubcommand();
+            if (!heartbeatService) {
+                await interaction.editReply({ content: 'Heartbeat service not available.' });
+                break;
+            }
+            const envOverrides = [];
+            if (process.env.HEARTBEAT_ENABLED !== undefined)
+                envOverrides.push('HEARTBEAT_ENABLED');
+            if (process.env.HEARTBEAT_INTERVAL_MS !== undefined)
+                envOverrides.push('HEARTBEAT_INTERVAL_MS');
+            if (process.env.HEARTBEAT_CHANNEL_ID !== undefined)
+                envOverrides.push('HEARTBEAT_CHANNEL_ID');
+            let warningPrefix = '';
+            if (envOverrides.length > 0) {
+                warningPrefix = `⚠️ **Warning**: Environment override(s) active: ${envOverrides.join(', ')}. Changes saved to config.json may not take effect until overrides are removed.\n\n`;
+            }
+            if (subcommand === 'on') {
+                const intervalStr = interaction.options.getString('interval') || '1h';
+                const targetChannel = interaction.options.getChannel('channel') || interaction.channel;
+                if (!targetChannel || typeof targetChannel.isTextBased !== 'function' || !targetChannel.isTextBased()) {
+                    await interaction.editReply({ content: '⚠️ Please select a valid text channel.' });
+                    break;
+                }
+                // Check permissions
+                const botUser = interaction.client.user;
+                const permissions = targetChannel.permissionsFor?.(botUser);
+                if (!permissions || !permissions.has('SendMessages') || !permissions.has('EmbedLinks')) {
+                    await interaction.editReply({ content: '⚠️ Bot does not have permission to send messages and embed links in that channel.' });
+                    break;
+                }
+                const intervalMs = (0, heartbeatService_1.parseInterval)(intervalStr);
+                if (intervalMs === null || intervalMs <= 0) {
+                    await interaction.editReply({ content: '⚠️ Invalid interval format. Use a value with a unit, e.g. "1d", "1h", "30m" (bare numbers are not allowed).' });
+                    break;
+                }
+                if (intervalMs < 10000) {
+                    await interaction.editReply({ content: '⚠️ Interval must be at least 10 seconds.' });
+                    break;
+                }
+                if (intervalMs > 2147483647) {
+                    await interaction.editReply({ content: '⚠️ Interval cannot be greater than 24.8 days (2147483647 ms).' });
+                    break;
+                }
+                await heartbeatService.updateConfig(true, intervalMs, targetChannel.id);
+                await interaction.editReply({
+                    content: `${warningPrefix}💓 Heartbeat enabled! Sending updates every **${intervalStr}** to channel <#${targetChannel.id}>.`
+                });
+            }
+            else if (subcommand === 'off') {
+                await heartbeatService.disable();
+                await interaction.editReply({ content: `${warningPrefix}💓 Heartbeat disabled.` });
+            }
+            else if (subcommand === 'status') {
+                const config = (0, config_1.loadConfig)();
+                const uptimeMs = Date.now() - heartbeatService.botStartTime;
+                const uptimeStr = (0, heartbeatService_1.formatDuration)(uptimeMs);
+                const lastActivityStr = (0, heartbeatService_1.formatRelativeTime)(heartbeatService.lastActivityTimestamp);
+                const activeWorkspaces = bridge.pool.getActiveWorkspaceNames();
+                const activeCount = activeWorkspaces.length;
+                const activeList = activeCount > 0 ? activeWorkspaces.join(', ') : 'None';
+                const intervalVal = config.heartbeatIntervalMs != null ? (0, heartbeatService_1.formatDuration)(config.heartbeatIntervalMs) : 'N/A';
+                const statusEmbed = new discord_js_1.EmbedBuilder()
+                    .setTitle('💓 Heartbeat Status')
+                    .setColor(config.heartbeatEnabled ? 0x00CC88 : 0x888888)
+                    .addFields({ name: 'Enabled', value: config.heartbeatEnabled ? '🟢 Yes' : '⚪ No', inline: true }, { name: 'Interval', value: config.heartbeatEnabled ? intervalVal : 'N/A', inline: true }, { name: 'Target Channel', value: config.heartbeatChannelId ? `<#${config.heartbeatChannelId}>` : 'N/A', inline: true }, { name: 'Active Sessions', value: `${activeCount} (${activeList})`, inline: true }, { name: 'Uptime', value: uptimeStr, inline: true }, { name: 'Last Activity', value: lastActivityStr, inline: true })
+                    .setTimestamp();
+                await interaction.editReply({ embeds: [statusEmbed] });
+            }
+            break;
+        }
+        case 'schedule': {
+            if (!scheduleService) {
+                await interaction.editReply({ content: 'Schedule service not available.' });
+                break;
+            }
+            const subcommand = interaction.options.getSubcommand();
+            if (subcommand === 'list') {
+                const schedules = scheduleService.listSchedules();
+                if (schedules.length === 0) {
+                    await interaction.editReply({ content: 'No scheduled tasks found.' });
+                    break;
+                }
+                let formatted = '';
+                let truncatedCount = 0;
+                for (const s of schedules) {
+                    const nextRunStr = formatNextRunTime(s.cronExpression);
+                    const line = `**ID:** ${s.id} | **Cron:** \`${s.cronExpression}\` | **Next:** ${nextRunStr} | **Prompt:** ${s.prompt}\n`;
+                    if (formatted.length + line.length > 3900) {
+                        truncatedCount = schedules.length - schedules.indexOf(s);
+                        break;
+                    }
+                    formatted += line;
+                }
+                if (truncatedCount > 0) {
+                    formatted += `\n*...and ${truncatedCount} more task(s) (truncated due to Discord size limit).*`;
+                }
+                const embed = new discord_js_1.EmbedBuilder()
+                    .setTitle('🕒 Scheduled Tasks')
+                    .setDescription(formatted)
+                    .setColor(0x00CC88);
+                await interaction.editReply({ embeds: [embed] });
+                break;
+            }
+            if (subcommand === 'add') {
+                const cronExpr = interaction.options.getString('cron', true);
+                const promptText = interaction.options.getString('prompt', true);
+                const workspacePath = wsHandler.getWorkspaceForChannel(interaction.channelId);
+                if (!workspacePath) {
+                    await interaction.editReply({ content: '⚠️ This channel is not bound to a workspace. Please bind it first.' });
+                    break;
+                }
+                try {
+                    const jobCb = scheduleService.getJobCallback();
+                    if (!jobCb) {
+                        await interaction.editReply({ content: '⚠️ Schedule service is still initializing. Please try again in a few seconds.' });
+                        break;
+                    }
+                    const record = scheduleService.addSchedule(cronExpr, promptText, workspacePath, interaction.channelId, jobCb);
+                    const nextRun = formatNextRunTime(cronExpr);
+                    const nextRunStr = nextRun !== 'Invalid Cron' ? ` (Next run: ${nextRun})` : '';
+                    await interaction.editReply({ content: `✅ Scheduled task added! (ID: ${record.id})${nextRunStr}` });
+                }
+                catch (error) {
+                    await interaction.editReply({ content: `❌ Failed to add schedule: ${error.message}` });
+                }
+                break;
+            }
+            if (subcommand === 'remove') {
+                const id = interaction.options.getInteger('id', true);
+                const success = scheduleService.removeSchedule(id);
+                if (success) {
+                    await interaction.editReply({ content: `✅ Removed scheduled task ID: ${id}` });
+                }
+                else {
+                    await interaction.editReply({ content: `⚠️ Scheduled task ID ${id} not found.` });
+                }
+                break;
+            }
+            if (subcommand === 'clear') {
+                const initialSchedules = scheduleService.listSchedules();
+                const count = initialSchedules.length;
+                if (count === 0) {
+                    await interaction.editReply({ content: '📅 No scheduled tasks found to clear.' });
+                    break;
+                }
+                const initialIdsJson = JSON.stringify(initialSchedules.map(s => s.id).sort((a, b) => a - b));
+                const confirmBtnId = `schedule_clear_confirm_${interaction.id}`;
+                const cancelBtnId = `schedule_clear_cancel_${interaction.id}`;
+                const row = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+                    .setCustomId(confirmBtnId)
+                    .setLabel(`${(0, i18n_1.t)('Confirm Clear')} (${count})`)
+                    .setStyle(discord_js_1.ButtonStyle.Danger), new discord_js_1.ButtonBuilder()
+                    .setCustomId(cancelBtnId)
+                    .setLabel((0, i18n_1.t)('Cancel'))
+                    .setStyle(discord_js_1.ButtonStyle.Secondary));
+                const message = await interaction.editReply({
+                    content: `⚠️ **Warning**: This will delete all **${count}** scheduled task(s) and reset the ID counter to 0. Are you sure you want to proceed?`,
+                    components: [row]
+                });
+                const collector = message.createMessageComponentCollector({
+                    filter: (i) => i.user.id === interaction.user.id && (i.customId === confirmBtnId || i.customId === cancelBtnId),
+                    time: 30000,
+                    max: 1
+                });
+                collector.on('collect', async (i) => {
+                    if (i.customId === confirmBtnId) {
+                        const currentSchedules = scheduleService.listSchedules();
+                        const currentIdsJson = JSON.stringify(currentSchedules.map(s => s.id).sort((a, b) => a - b));
+                        if (initialIdsJson !== currentIdsJson) {
+                            await i.update({
+                                content: '⚠️ **Action aborted**: The scheduled tasks list changed while waiting for confirmation. No schedules were cleared.',
+                                components: []
+                            });
+                            return;
+                        }
+                        scheduleService.resetSchedules();
+                        await i.update({
+                            content: `✅ Successfully removed all **${count}** scheduled task(s) and reset the task ID counter to 0.`,
+                            components: []
+                        });
+                    }
+                    else {
+                        await i.update({
+                            content: '❌ Action cancelled. Scheduled tasks were not cleared.',
+                            components: []
+                        });
+                    }
+                });
+                collector.on('end', async (collected) => {
+                    if (collected.size === 0) {
+                        await interaction.editReply({
+                            content: '⚠️ Action timed out. Scheduled tasks were not cleared.',
+                            components: []
+                        }).catch(() => { });
+                    }
+                });
+                break;
+            }
+            if (subcommand === 'backup') {
+                const json = scheduleService.backupSchedules();
+                const buffer = Buffer.from(json, 'utf-8');
+                await interaction.editReply({
+                    content: '📋 **LazyGravity Schedules Backup**',
+                    files: [{
+                            attachment: buffer,
+                            name: 'schedules_backup.json'
+                        }]
+                });
+                break;
+            }
+            if (subcommand === 'restore') {
+                const attachment = interaction.options.getAttachment('file', true);
+                if (!attachment.name.endsWith('.json')) {
+                    await interaction.editReply({ content: '❌ Attachment must be a `.json` file.' });
+                    break;
+                }
+                try {
+                    // Download file content using global fetch (available in Node 18+)
+                    const response = await fetch(attachment.url);
+                    if (!response.ok)
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    const jsonText = await response.text();
+                    const jobCb = scheduleService.getJobCallback();
+                    if (!jobCb) {
+                        await interaction.editReply({ content: '⚠️ Schedule service is still initializing. Please try again in a few seconds.' });
+                        break;
+                    }
+                    const restoredCount = scheduleService.restoreSchedules(jsonText, jobCb);
+                    await interaction.editReply({ content: `✅ Successfully restored ${restoredCount} scheduled tasks from backup!` });
+                }
+                catch (error) {
+                    await interaction.editReply({ content: `❌ Failed to restore schedules: ${error.message}` });
+                }
+                break;
+            }
+            break;
+        }
         default:
             await interaction.editReply({
                 content: `Unknown command: /${commandName}`,

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

@@ -112,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);
@@ -1448,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.`,
@@ -255,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(() => { });
@@ -266,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})`);
@@ -437,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`);
                             }

package/dist/services/heartbeatService.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatService = void 0;
+exports.parseInterval = parseInterval;
+exports.formatDuration = formatDuration;
+exports.formatRelativeTime = formatRelativeTime;
+const discord_js_1 = require("discord.js");
+const logger_1 = require("../utils/logger");
+const configLoader_1 = require("../utils/configLoader");
+class HeartbeatService {
+    client = null;
+    bridge = null;
+    intervalId = null;
+    generationToken = 0;
+    isSending = false;
+    botStartTime = Date.now();
+    lastActivityTimestamp = Date.now();
+    constructor() { }
+    init(client, bridge) {
+        this.client = client;
+        this.bridge = bridge;
+        this.botStartTime = Date.now();
+        this.lastActivityTimestamp = Date.now();
+    }
+    recordActivity() {
+        this.lastActivityTimestamp = Date.now();
+    }
+    start() {
+        this.stop();
+        const config = configLoader_1.ConfigLoader.load();
+        if (!config.heartbeatEnabled) {
+            logger_1.logger.info('[HeartbeatService] Periodic heartbeat is disabled.');
+            return;
+        }
+        const channelId = config.heartbeatChannelId;
+        if (!channelId) {
+            logger_1.logger.warn('[HeartbeatService] Enabled but heartbeatChannelId is not configured.');
+            return;
+        }
+        let interval = config.heartbeatIntervalMs ?? 3600000;
+        if (interval < 10000) {
+            logger_1.logger.warn(`[HeartbeatService] Interval ${interval}ms is too low. Clamping to 10000ms.`);
+            interval = 10000;
+        }
+        else if (interval > 2147483647) {
+            logger_1.logger.warn(`[HeartbeatService] Interval ${interval}ms is too high (max is 2147483647ms). Clamping to 2147483647ms.`);
+            interval = 2147483647;
+        }
+        logger_1.logger.info(`[HeartbeatService] Starting periodic heartbeat every ${interval}ms to channel ${channelId}`);
+        // Run immediately on start
+        this.sendHeartbeat().catch(err => {
+            logger_1.logger.error('[HeartbeatService] Failed to send initial heartbeat:', err);
+        });
+        this.intervalId = setInterval(() => {
+            this.sendHeartbeat().catch(err => {
+                logger_1.logger.error('[HeartbeatService] Failed to send periodic heartbeat:', err);
+            });
+        }, interval);
+    }
+    stop() {
+        this.generationToken++;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    async updateConfig(enabled, intervalMs, channelId) {
+        this.generationToken++;
+        const config = configLoader_1.ConfigLoader.load();
+        // If channel changed, clear the last message ID
+        if (config.heartbeatChannelId !== channelId) {
+            if (config.heartbeatChannelId && config.heartbeatLastMessageId) {
+                try {
+                    const oldChannel = await this.client?.channels.fetch(config.heartbeatChannelId);
+                    if (oldChannel && oldChannel.isTextBased()) {
+                        const oldMsg = await oldChannel.messages.fetch(config.heartbeatLastMessageId);
+                        if (oldMsg) {
+                            await oldMsg.delete().catch(() => { });
+                        }
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.debug('[HeartbeatService] Failed to delete old heartbeat message from previous channel:', err);
+                }
+            }
+            configLoader_1.ConfigLoader.save({ heartbeatLastMessageId: undefined });
+        }
+        // Save to config.json
+        configLoader_1.ConfigLoader.save({
+            heartbeatEnabled: enabled,
+            heartbeatIntervalMs: intervalMs,
+            heartbeatChannelId: channelId,
+        });
+        logger_1.logger.info(`[HeartbeatService] Config updated: enabled=${enabled}, interval=${intervalMs}ms, channel=${channelId}`);
+        // Restart loop
+        this.start();
+    }
+    async disable() {
+        this.generationToken++;
+        const config = configLoader_1.ConfigLoader.load();
+        if (config.heartbeatChannelId && config.heartbeatLastMessageId) {
+            try {
+                const oldChannel = await this.client?.channels.fetch(config.heartbeatChannelId);
+                if (oldChannel && oldChannel.isTextBased()) {
+                    const oldMsg = await oldChannel.messages.fetch(config.heartbeatLastMessageId);
+                    if (oldMsg) {
+                        await oldMsg.delete().catch(() => { });
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.debug('[HeartbeatService] Failed to delete heartbeat message upon disabling:', err);
+            }
+        }
+        configLoader_1.ConfigLoader.save({
+            heartbeatEnabled: false,
+            heartbeatLastMessageId: undefined,
+        });
+        this.stop();
+        logger_1.logger.info('[HeartbeatService] Heartbeat disabled.');
+    }
+    async sendHeartbeat() {
+        if (!this.client || !this.bridge) {
+            logger_1.logger.warn('[HeartbeatService] Cannot send heartbeat: client or bridge not initialized.');
+            return;
+        }
+        if (this.isSending) {
+            logger_1.logger.debug('[HeartbeatService] Heartbeat send already in flight. Skipping overlapping execution.');
+            return;
+        }
+        const gen = this.generationToken;
+        this.isSending = true;
+        const config = configLoader_1.ConfigLoader.load();
+        const channelId = config.heartbeatChannelId;
+        if (!channelId) {
+            this.isSending = false;
+            return;
+        }
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug(`[HeartbeatService] Aborting heartbeat send: stale generation (expected ${gen}, current ${this.generationToken})`);
+                return;
+            }
+            if (!channel || !channel.isTextBased()) {
+                logger_1.logger.warn(`[HeartbeatService] Channel ${channelId} not found or is not a text channel.`);
+                return;
+            }
+            const embed = this.buildHeartbeatEmbed();
+            const lastMessageId = config.heartbeatLastMessageId;
+            if (lastMessageId) {
+                try {
+                    const message = await channel.messages.fetch(lastMessageId);
+                    if (gen !== this.generationToken) {
+                        logger_1.logger.debug('[HeartbeatService] Aborting message edit: stale generation');
+                        return;
+                    }
+                    if (message && message.author.id === this.client.user?.id) {
+                        await message.edit({ embeds: [embed] });
+                        logger_1.logger.debug(`[HeartbeatService] Updated heartbeat message in-place: ${lastMessageId}`);
+                        return;
+                    }
+                }
+                catch (fetchErr) {
+                    logger_1.logger.debug(`[HeartbeatService] Failed to fetch or edit message ${lastMessageId}, sending new one.`);
+                }
+            }
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug('[HeartbeatService] Aborting message send: stale generation');
+                return;
+            }
+            // Send new message
+            const newMsg = await channel.send({ embeds: [embed] });
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug(`[HeartbeatService] Stale generation after send. Deleting new message ${newMsg.id} to avoid leakage.`);
+                await newMsg.delete().catch(() => { });
+                return;
+            }
+            configLoader_1.ConfigLoader.save({ heartbeatLastMessageId: newMsg.id });
+            logger_1.logger.info(`[HeartbeatService] Sent new heartbeat message: ${newMsg.id}`);
+        }
+        catch (error) {
+            logger_1.logger.error('[HeartbeatService] Error in sendHeartbeat:', error);
+        }
+        finally {
+            this.isSending = false;
+        }
+    }
+    buildHeartbeatEmbed() {
+        const uptimeMs = Date.now() - this.botStartTime;
+        const uptimeStr = formatDuration(uptimeMs);
+        const activeWorkspaces = this.bridge?.pool.getActiveWorkspaceNames() || [];
+        const activeCount = activeWorkspaces.length;
+        const activeList = activeCount > 0 ? activeWorkspaces.join(', ') : 'None';
+        const lastActivityStr = formatRelativeTime(this.lastActivityTimestamp);
+        return new discord_js_1.EmbedBuilder()
+            .setTitle('💓 LazyGravity Heartbeat')
+            .setColor(0x00CC88)
+            .addFields({ name: 'Status', value: '🟢 Running', inline: true }, { name: 'Uptime', value: uptimeStr, inline: true }, { name: 'Active Sessions', value: `${activeCount} (${activeList})`, inline: true }, { name: 'Last Activity', value: lastActivityStr, inline: true })
+            .setFooter({ text: `Last updated: ${new Date().toLocaleString()}` })
+            .setTimestamp();
+    }
+}
+exports.HeartbeatService = HeartbeatService;
+/**
+ * Parse a duration string like "1h", "6h", "30m", or "2d" to milliseconds.
+ * Requiring a unit prevents ambiguity with bare numbers.
+ */
+function parseInterval(str) {
+    const match = str.trim().toLowerCase().match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match)
+        return null;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 'ms': return value;
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        case 'd': return value * 24 * 60 * 60 * 1000;
+        default: return null;
+    }
+}
+/**
+ * Format milliseconds to a human-readable duration (e.g. "2h 15m")
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor((ms / 1000) % 60);
+    const minutes = Math.floor((ms / (1000 * 60)) % 60);
+    const hours = Math.floor((ms / (1000 * 60 * 60)) % 24);
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+/**
+ * Format a past timestamp to a relative string (e.g. "5m ago")
+ */
+function formatRelativeTime(timestamp) {
+    const diff = Date.now() - timestamp;
+    if (diff < 5000)
+        return 'just now';
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/dist/services/scheduleService.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduleService = void 0;
 const cron = __importStar(require("node-cron"));
+const logger_1 = require("../utils/logger");
 /**
  * Service class for managing scheduled jobs.
  *
@@ -46,9 +47,16 @@ class ScheduleService {
     repo;
     /** Map managing active cron tasks (schedule ID -> ScheduledTask) */
     activeTasks = new Map();
+    jobCallback;
     constructor(repo) {
         this.repo = repo;
     }
+    /**
+     * Get the stored job callback.
+     */
+    getJobCallback() {
+        return this.jobCallback;
+    }
     /**
      * Called on bot startup. Loads all enabled schedules from DB and registers/resumes them with node-cron.
      *
@@ -56,6 +64,7 @@ class ScheduleService {
      * @returns Number of restored schedules
      */
     restoreAll(jobCallback) {
+        this.jobCallback = jobCallback;
         const enabledSchedules = this.repo.findEnabled();
         for (const schedule of enabledSchedules) {
             this.registerCronTask(schedule, jobCallback);
@@ -73,20 +82,36 @@ class ScheduleService {
      * @returns Created schedule record
      * @throws On invalid cron expression
      */
-    addSchedule(cronExpression, prompt, workspacePath, jobCallback) {
+    addSchedule(cronExpression, prompt, workspacePath, channelIdOrCallback, jobCallback) {
+        let finalChannelId = '';
+        let finalJobCallback;
+        if (typeof channelIdOrCallback === 'function') {
+            finalJobCallback = channelIdOrCallback;
+        }
+        else {
+            finalChannelId = channelIdOrCallback;
+            finalJobCallback = jobCallback;
+        }
+        if (!finalJobCallback) {
+            throw new Error('Job callback is not initialized.');
+        }
         // Validate cron expression
         if (!cron.validate(cronExpression)) {
             throw new Error(`Invalid cron expression: ${cronExpression}`);
         }
         // Save to DB
-        const record = this.repo.create({
+        const recordInput = {
             cronExpression,
             prompt,
             workspacePath,
             enabled: true,
-        });
+        };
+        if (finalChannelId) {
+            recordInput.channelId = finalChannelId;
+        }
+        const record = this.repo.create(recordInput);
         // Register with node-cron
-        this.registerCronTask(record, jobCallback);
+        this.registerCronTask(record, finalJobCallback);
         return record;
     }
     /**
@@ -115,6 +140,76 @@ class ScheduleService {
         }
         this.activeTasks.clear();
     }
+    /**
+     * Remove all scheduled tasks.
+     * Stops all active cron tasks in memory, empties the database table,
+     * and resets the autoincrement ID back to 0.
+     */
+    resetSchedules() {
+        this.repo.reset();
+        this.stopAll();
+    }
+    /**
+     * Export all schedules as a JSON string
+     */
+    backupSchedules() {
+        const list = this.listSchedules();
+        // Export only portable fields (exclude autoincrement ID and timestamps)
+        const portable = list.map(s => ({
+            cronExpression: s.cronExpression,
+            prompt: s.prompt,
+            workspacePath: s.workspacePath,
+            channelId: s.channelId,
+            enabled: s.enabled
+        }));
+        return JSON.stringify(portable, null, 2);
+    }
+    restoreSchedules(jsonContent, jobCallback) {
+        if (!jobCallback) {
+            throw new Error('Job callback is not initialized.');
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonContent);
+        }
+        catch (err) {
+            throw new Error('Invalid backup format: root must be an array of schedule objects.');
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error('Invalid backup format: root must be an array of schedule objects.');
+        }
+        // Validate items
+        const validated = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object') {
+                throw new Error('Invalid backup format: each schedule must contain cronExpression, prompt, and workspacePath.');
+            }
+            if (typeof item.cronExpression !== 'string' || typeof item.prompt !== 'string' || typeof item.workspacePath !== 'string') {
+                throw new Error('Invalid backup format: each schedule must contain cronExpression, prompt, and workspacePath.');
+            }
+            if (!cron.validate(item.cronExpression)) {
+                throw new Error(`Invalid cron expression in backup: "${item.cronExpression}"`);
+            }
+            validated.push({
+                cronExpression: item.cronExpression,
+                prompt: item.prompt,
+                workspacePath: item.workspacePath,
+                channelId: typeof item.channelId === 'string' ? item.channelId : undefined,
+                enabled: typeof item.enabled === 'boolean' ? item.enabled : true
+            });
+        }
+        // Write to DB first (atomic transaction)
+        const restoredRecords = this.repo.bulkRestore(validated);
+        // Stop memory crons now that DB write succeeded
+        this.stopAll();
+        // Resume crons in memory
+        for (const record of restoredRecords) {
+            if (record.enabled) {
+                this.registerCronTask(record, jobCallback);
+            }
+        }
+        return restoredRecords.length;
+    }
     /**
      * Get a list of all schedules
      */
@@ -125,7 +220,9 @@ class ScheduleService {
      * Internal method to register a task with node-cron
      */
     registerCronTask(schedule, jobCallback) {
+        logger_1.logger.info(`[Schedule] Registering cron task ID ${schedule.id} with expression "${schedule.cronExpression}"`);
         const task = cron.schedule(schedule.cronExpression, () => {
+            logger_1.logger.info(`[Schedule] Cron trigger fired for task ID ${schedule.id}`);
             jobCallback(schedule);
         });
         this.activeTasks.set(schedule.id, task);

package/dist/utils/configLoader.js

@@ -113,6 +113,10 @@ function mergeConfig(persisted) {
     if (platforms.includes('telegram') && !telegramToken) {
         throw new Error('TELEGRAM_BOT_TOKEN is required when platforms include "telegram"');
     }
+    const heartbeatEnabled = resolveBoolean(process.env.HEARTBEAT_ENABLED, persisted.heartbeatEnabled, false);
+    const heartbeatIntervalMs = resolvePositiveInt(process.env.HEARTBEAT_INTERVAL_MS, persisted.heartbeatIntervalMs, 3600000);
+    const heartbeatChannelId = process.env.HEARTBEAT_CHANNEL_ID ?? persisted.heartbeatChannelId ?? undefined;
+    const heartbeatLastMessageId = persisted.heartbeatLastMessageId ?? undefined;
     return {
         discordToken,
         clientId,
@@ -128,6 +132,10 @@ function mergeConfig(persisted) {
         telegramAllowedUserIds,
         platforms,
         cdpHost,
+        heartbeatEnabled,
+        heartbeatIntervalMs,
+        heartbeatChannelId,
+        heartbeatLastMessageId,
     };
 }
 function resolveAllowedUserIds(persisted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Control Antigravity from anywhere — a local, secure bot (Discord + Telegram) that lets you remotely operate Antigravity on your home PC from your smartphone.",
   "main": "dist/index.js",
   "bin": {
@@ -50,6 +50,7 @@
     "@inquirer/select": "^5.1.0",
     "better-sqlite3": "^12.6.2",
     "commander": "^15.0.0",
+    "cron-parser": "^5.6.1",
     "discord.js": "^14.25.1",
     "dotenv": "^17.3.1",
     "grammy": "^1.41.1",