lazy-gravity 0.10.0 → 0.12.0

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");
@@ -191,11 +196,15 @@ function createSerialTaskQueueForTest(queueName, traceId) {
 async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService, modelService, inboundImages = [], options) {
     // Completion signal — called exactly once when the entire prompt lifecycle ends
     let completionSignaled = false;
+    let onApprovalRef = null;
     const signalCompletion = (exitPath) => {
         if (completionSignaled)
             return;
         completionSignaled = true;
         logger_1.logger.debug(`[sendPrompt:${message.channelId}] signalCompletion via ${exitPath}`);
+        if (onApprovalRef) {
+            cdp.off('approval_required', onApprovalRef);
+        }
         options?.onFullCompletion?.();
     };
     // Resolve output format once at the start (no mid-response switches)
@@ -587,6 +596,8 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             return;
         }
         const startTime = Date.now();
+        let earlyConvIdResolved = false;
+        let earlyConvIdInFlight = false;
         await upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, '', PHASE_COLORS.thinking, (0, i18n_1.t)('⏱️ Elapsed: 0s | Process log'), { source: 'initial' });
         const monitor = new responseMonitor_1.ResponseMonitor({
             cdpService: cdp,
@@ -613,6 +624,30 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                     expectedVersion: activityVersion,
                     skipWhenFinalized: true,
                 }).catch(() => { });
+                // Try to resolve conversation_id early if not already bound
+                const { artifactService, chatSessionRepo, chatSessionService } = options || {};
+                if (!earlyConvIdResolved && !earlyConvIdInFlight && artifactService && chatSessionRepo && chatSessionService) {
+                    earlyConvIdInFlight = true;
+                    chatSessionService.getCurrentSessionInfo(cdp)
+                        .then((sessionInfo) => {
+                        if (sessionInfo && sessionInfo.title && sessionInfo.title !== (0, i18n_1.t)('(Untitled)')) {
+                            const session = chatSessionRepo.findByChannelId(message.channelId);
+                            const workspaceDirName = (session
+                                ? bridge.pool.extractProjectName(session.workspacePath)
+                                : cdp.getCurrentWorkspaceName()) ?? undefined;
+                            const convId = artifactService.findConversationByTitle(sessionInfo.title, workspaceDirName);
+                            if (convId) {
+                                chatSessionRepo.setConversationId(message.channelId, convId);
+                                earlyConvIdResolved = true;
+                                logger_1.logger.debug(`[EarlyBinding] Saved conversation_id: "${convId}" for channel: ${message.channelId}`);
+                            }
+                        }
+                    })
+                        .catch(() => { })
+                        .finally(() => {
+                        earlyConvIdInFlight = false;
+                    });
+                }
             },
             onProgress: (text) => {
                 if (isFinalized)
@@ -706,6 +741,12 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                         const components = [];
                         if (!citedFiles)
                             citedFiles = [];
+                        // Only pause when newly created conversation folders and files need to flush to disk
+                        const existingConvId = options?.chatSessionRepo?.findByChannelId(message.channelId)?.conversationId;
+                        if (!existingConvId) {
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                        }
+                        let activeConversationId = undefined;
                         if (options && message.guild) {
                             try {
                                 const sessionInfo = await options.chatSessionService.getCurrentSessionInfo(cdp);
@@ -733,6 +774,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                         const convId = options.artifactService.findConversationByTitle(sessionInfo.title, workspaceDirName);
                                         if (convId) {
                                             options.chatSessionRepo.setConversationId(message.channelId, convId);
+                                            activeConversationId = convId;
                                         }
                                     }
                                 }
@@ -741,6 +783,51 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                 logger_1.logger.error('[Rename] Failed to get title from Antigravity and rename:', e);
                             }
                         }
+                        const classifiedForFiles = monitor.getLastClassified();
+                        if (classifiedForFiles?.fileChanges && classifiedForFiles.fileChanges.length > 0) {
+                            for (const fc of classifiedForFiles.fileChanges) {
+                                if (!citedFiles.includes(fc.path)) {
+                                    citedFiles.push(fc.path);
+                                }
+                            }
+                        }
+                        if (!activeConversationId && options?.chatSessionRepo) {
+                            activeConversationId = options.chatSessionRepo.findByChannelId(message.channelId)?.conversationId ?? undefined;
+                        }
+                        if (activeConversationId && options?.artifactService) {
+                            const artifacts = options.artifactService.listArtifacts(activeConversationId);
+                            const planArt = artifacts.find(art => art.artifactType === 'ARTIFACT_TYPE_IMPLEMENTATION_PLAN' ||
+                                art.filename.toLowerCase() === 'implementation_plan.md');
+                            let planTime = 0;
+                            if (planArt) {
+                                try {
+                                    planTime = fs_1.default.statSync(planArt.absolutePath).mtimeMs;
+                                }
+                                catch { /* ignore */ }
+                            }
+                            for (const art of artifacts) {
+                                const nameWithExt = art.filename;
+                                const nameWithoutExt = art.filename.replace(/\.[^/.]+$/, "");
+                                const regex = new RegExp(`\\b${nameWithoutExt.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\b`, 'i');
+                                const mentionsArtifact = finalOutputText.includes(nameWithExt) || finalOutputText.includes(`\`${nameWithoutExt}\``) || regex.test(finalOutputText);
+                                const isTask = art.artifactType === 'ARTIFACT_TYPE_TASK' || nameWithExt.toLowerCase() === 'task.md';
+                                const isWalkthrough = art.artifactType === 'ARTIFACT_TYPE_WALKTHROUGH' || nameWithExt.toLowerCase() === 'walkthrough.md';
+                                let isSpecialArtifact = false;
+                                if (isTask || isWalkthrough) {
+                                    let artTime = 0;
+                                    try {
+                                        artTime = fs_1.default.statSync(art.absolutePath).mtimeMs;
+                                    }
+                                    catch { /* ignore */ }
+                                    if (artTime > planTime) {
+                                        isSpecialArtifact = true;
+                                    }
+                                }
+                                if ((mentionsArtifact || isSpecialArtifact) && !citedFiles.includes(nameWithExt)) {
+                                    citedFiles.push(nameWithExt);
+                                }
+                            }
+                        }
                         if (citedFiles && citedFiles.length > 0) {
                             // Strip trailing punctuation and deduplicate
                             let uniqueFiles = Array.from(new Set(citedFiles.map(f => {
@@ -756,38 +843,82 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                             // Max 5 buttons per row in Discord
                             for (let i = 0; i < Math.min(uniqueFiles.length, 5); i++) {
                                 let fileUrl = uniqueFiles[i];
+                                let isArtifactMatch = false;
+                                let artifactDisplayName = fileUrl;
+                                if (activeConversationId && options?.artifactService) {
+                                    const artifacts = options.artifactService.listArtifacts(activeConversationId);
+                                    const rawName = fileUrl.replace(/^file:\/\/\//, '');
+                                    const matched = artifacts.find(a => a.filename.toLowerCase() === fileUrl.toLowerCase() ||
+                                        a.filename.toLowerCase() === rawName.toLowerCase());
+                                    if (matched) {
+                                        isArtifactMatch = true;
+                                        fileUrl = `file:///${matched.absolutePath.replace(/\\/g, '/')}`;
+                                        artifactDisplayName = matched.filename;
+                                    }
+                                }
                                 const wsPath = cdp.getCurrentWorkspacePath();
                                 if (!wsPath) {
                                     continue;
                                 }
-                                if (!fileUrl.startsWith('file:///') && !path_1.default.isAbsolute(fileUrl)) {
-                                    fileUrl = `file:///${path_1.default.resolve(wsPath, fileUrl).replace(/\\/g, '/')}`;
-                                }
-                                let fsPath = fileUrl.replace(/^file:\/\/\//, '');
-                                if (path_1.default.sep === '/' && !fsPath.startsWith('/')) {
-                                    fsPath = '/' + fsPath;
-                                }
-                                else if (process.platform === 'win32' && fsPath.startsWith('/')) {
-                                    fsPath = fsPath.substring(1);
-                                }
-                                const relative = path_1.default.relative(wsPath, fsPath);
-                                if (relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
-                                    continue;
-                                }
-                                if (!fs_1.default.existsSync(fsPath)) {
-                                    continue;
+                                if (!isArtifactMatch) {
+                                    if (!fileUrl.startsWith('file:///') && !path_1.default.isAbsolute(fileUrl)) {
+                                        fileUrl = `file:///${path_1.default.resolve(wsPath, fileUrl).replace(/\\/g, '/')}`;
+                                    }
+                                    let fsPath = fileUrl.replace(/^file:\/\/\//, '');
+                                    if (path_1.default.sep === '/' && !fsPath.startsWith('/')) {
+                                        fsPath = '/' + fsPath;
+                                    }
+                                    else if (process.platform === 'win32' && fsPath.startsWith('/')) {
+                                        fsPath = fsPath.substring(1);
+                                    }
+                                    const relative = path_1.default.relative(wsPath, fsPath);
+                                    const isArtifact = fsPath.includes('.gemini') && fsPath.includes('antigravity') && fsPath.includes('brain');
+                                    if (!isArtifact && (relative.startsWith('..') || path_1.default.isAbsolute(relative))) {
+                                        continue;
+                                    }
+                                    if (!fs_1.default.existsSync(fsPath)) {
+                                        continue;
+                                    }
                                 }
                                 let displayName = fileUrl;
-                                if (displayName.startsWith('file:///')) {
+                                if (isArtifactMatch) {
+                                    displayName = artifactDisplayName;
+                                }
+                                else if (displayName.startsWith('file:///')) {
                                     const parts = displayName.split('/');
                                     displayName = parts[parts.length - 1];
                                 }
                                 const hashId = Math.random().toString(36).substring(2, 10);
                                 fileOpenCache_1.fileOpenCache.set(hashId, fileUrl);
+                                let customId = `file_open:cache:${hashId}`;
+                                if (isArtifactMatch && activeConversationId && displayName) {
+                                    const artId = `file_open:art:${activeConversationId}:${displayName}`;
+                                    if (artId.length < 100) {
+                                        customId = artId;
+                                    }
+                                }
+                                else if (wsPath) {
+                                    let fsPath = fileUrl.replace(/^file:\/\/\//, '');
+                                    if (path_1.default.sep === '/' && !fsPath.startsWith('/')) {
+                                        fsPath = '/' + fsPath;
+                                    }
+                                    else if (process.platform === 'win32' && fsPath.startsWith('/')) {
+                                        fsPath = fsPath.substring(1);
+                                    }
+                                    const resolvedFsPath = path_1.default.resolve(fsPath);
+                                    const relative = path_1.default.relative(wsPath, resolvedFsPath);
+                                    if (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)) {
+                                        const relSlash = relative.replace(/\\/g, '/');
+                                        const relId = `file_open:rel:${relSlash}`;
+                                        if (relId.length < 100) {
+                                            customId = relId;
+                                        }
+                                    }
+                                }
                                 row.addComponents(new discord_js_1.ButtonBuilder()
-                                    .setCustomId(`file_open:${hashId}`)
-                                    .setLabel(`Open ${displayName.substring(0, 20)}`)
-                                    .setStyle(discord_js_1.ButtonStyle.Primary));
+                                    .setCustomId(customId)
+                                    .setLabel(isArtifactMatch ? `Review ${displayName.substring(0, 15)}` : `Open ${displayName.substring(0, 20)}`)
+                                    .setStyle(isArtifactMatch ? discord_js_1.ButtonStyle.Success : discord_js_1.ButtonStyle.Primary));
                             }
                             if (row.components.length > 0) {
                                 components.push(row);
@@ -895,6 +1026,32 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                 }
             },
         });
+        onApprovalRef = async () => {
+            if (isFinalized)
+                return;
+            const textToUse = lastProgressText || monitor.getLastText() || '';
+            const separated = (0, discordFormatter_1.splitOutputAndLogs)(textToUse);
+            const outputText = separated.output || textToUse;
+            if (outputText && outputText.trim().length > 0) {
+                liveResponseUpdateVersion += 1;
+                const responseVersion = liveResponseUpdateVersion;
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                await upsertLiveResponseEmbeds((0, i18n_1.t)('Response'), outputText, PHASE_COLORS.thinking, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Awaiting Approval`), {
+                    source: 'approval-pause',
+                    expectedVersion: responseVersion,
+                    skipWhenFinalized: true,
+                }).catch(() => { });
+            }
+        };
+        cdp.on('approval_required', onApprovalRef);
+        if (options?.onMonitorCreated) {
+            options.onMonitorCreated({
+                stop: async () => {
+                    isFinalized = true;
+                    await monitor.stop();
+                }
+            });
+        }
         await monitor.start();
         // 1-second elapsed timer — updates footer independently of process log events
         const elapsedTimer = setInterval(() => {
@@ -948,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)
@@ -959,6 +1120,8 @@ const startBot = async (cliLogLevel) => {
         .filter((account) => typeof account.userDataDir === 'string' && account.userDataDir.trim().length > 0)
         .map((account) => [account.name, account.userDataDir.trim()]));
     const bridge = (0, cdpBridgeManager_1.initCdpBridge)(config.autoApproveFileEdits, accountPorts, accountUserDataDirs);
+    bridge.chatSessionRepo = chatSessionRepo;
+    bridge.artifactService = artifactService;
     // Initialize CDP-dependent services (constructor CDP dependency removed)
     const chatSessionService = new chatSessionService_1.ChatSessionService();
     const titleGenerator = new titleGeneratorService_1.TitleGeneratorService();
@@ -1009,7 +1172,20 @@ const startBot = async (cliLogLevel) => {
             accountPrefRepo,
             accounts: config.antigravityAccounts,
         });
-        await (0, antigravityLauncher_1.startAntigravity)(accountPorts[accountName] ?? 9222);
+        const status = await (0, antigravityLauncher_1.startAntigravity)(accountPorts[accountName] ?? 9222);
+        if (status === 'started') {
+            const cdp = new cdpService_1.CdpService({ portsToScan: [accountPorts[accountName] ?? 9222] });
+            try {
+                await cdp.connect();
+                await cdp.openChatPanel();
+            }
+            catch (e) {
+                // ignore
+            }
+            finally {
+                await cdp.disconnect().catch(() => { });
+            }
+        }
     });
     const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool, (channelId, userId) => (0, accountUtils_1.resolveScopedAccountName)({
         channelId,
@@ -1050,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);
                 }
@@ -1090,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)({
@@ -1123,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) {
@@ -1245,6 +1493,8 @@ const startBot = async (cliLogLevel) => {
                 accountPrefRepo,
                 channelPrefRepo,
                 antigravityAccounts: config.antigravityAccounts,
+                heartbeatService,
+                workspaceQueue,
             }));
             await client.login(discordToken);
         } // end: else (credentials present)
@@ -1515,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);
@@ -2043,7 +2305,9 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
                         const candidatePath = path_1.default.isAbsolute(rawPath) ? rawPath : path_1.default.join(wsPath, rawPath);
                         const relative = path_1.default.relative(wsPath, candidatePath);
                         if (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)) {
-                            resolvedPath = candidatePath;
+                            if (fs_1.default.existsSync(candidatePath)) {
+                                resolvedPath = candidatePath;
+                            }
                         }
                     }
                 }
@@ -2079,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}`,