lazy-gravity 0.7.1 → 0.8.0

package/dist/bot/index.js

@@ -58,6 +58,7 @@ const accountPreferenceRepository_1 = require("../database/accountPreferenceRepo
 const workspaceBindingRepository_1 = require("../database/workspaceBindingRepository");
 const channelPreferenceRepository_1 = require("../database/channelPreferenceRepository");
 const chatSessionRepository_1 = require("../database/chatSessionRepository");
+const artifactThreadRepository_1 = require("../database/artifactThreadRepository");
 const workspaceService_1 = require("../services/workspaceService");
 const workspaceCommandHandler_1 = require("../commands/workspaceCommandHandler");
 const chatCommandHandler_1 = require("../commands/chatCommandHandler");
@@ -84,6 +85,8 @@ const autoAcceptUi_1 = require("../ui/autoAcceptUi");
 const accountUi_1 = require("../ui/accountUi");
 const outputUi_1 = require("../ui/outputUi");
 const screenshotUi_1 = require("../ui/screenshotUi");
+const artifactsUi_1 = require("../ui/artifactsUi");
+const artifactService_1 = require("../services/artifactService");
 const userPreferenceRepository_1 = require("../database/userPreferenceRepository");
 const accountUtils_1 = require("../utils/accountUtils");
 const plainTextFormatter_1 = require("../utils/plainTextFormatter");
@@ -706,6 +709,13 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                         await options.channelManager.renameChannel(message.guild, message.channelId, formattedName);
                                         options.chatSessionRepo.updateDisplayName(message.channelId, sessionInfo.title);
                                     }
+                                    // Persist conversation_id for artifact picker resolution
+                                    if (options.artifactService) {
+                                        const convId = options.artifactService.findConversationByTitle(sessionInfo.title);
+                                        if (convId) {
+                                            options.chatSessionRepo.setConversationId(message.channelId, convId);
+                                        }
+                                    }
                                 }
                             }
                             catch (e) {
@@ -812,6 +822,8 @@ 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 artifactService = new artifactService_1.ArtifactService();
     const workspaceService = new workspaceService_1.WorkspaceService(config.workspaceBaseDir);
     const channelManager = new channelManager_1.ChannelManager();
     // Auto-launch Antigravity with CDP port if not already running
@@ -967,8 +979,10 @@ const startBot = async (cliLogLevel) => {
                 channelPrefRepo,
                 chatSessionRepo,
                 chatSessionService,
+                artifactThreadRepo,
+                artifactService,
                 antigravityAccounts: config.antigravityAccounts,
-                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepo),
+                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, chatSessionService, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo, accountPrefRepoArg, channelPrefRepoArg, antigravityAccountsArg, chatSessionRepo, artifactService),
                 handleTemplateUse: async (interaction, templateId) => {
                     const template = templateRepo.findById(templateId);
                     if (!template) {
@@ -1055,6 +1069,7 @@ const startBot = async (cliLogLevel) => {
                                 channelManager,
                                 titleGenerator,
                                 userPrefRepo,
+                                artifactService,
                                 extractionMode: config.extractionMode,
                             },
                         });
@@ -1073,6 +1088,7 @@ const startBot = async (cliLogLevel) => {
                 chatSessionRepo,
                 channelManager,
                 titleGenerator,
+                artifactService,
                 client,
                 sendPromptToAntigravity: async (_bridge, message, prompt, cdp, _modeService, _modelService, inboundImages = [], options) => promptDispatcher.send({
                     message,
@@ -1261,6 +1277,7 @@ const startBot = async (cliLogLevel) => {
                 { command: 'stop', description: 'Interrupt active LLM generation' },
                 { command: 'help', description: 'Show available commands' },
                 { command: 'ping', description: 'Check bot latency' },
+                { command: 'artifacts', description: 'Browse session artifacts' },
             ]).catch((e) => {
                 logger_1.logger.warn('Failed to register Telegram commands:', e instanceof Error ? e.message : e);
             });
@@ -1352,7 +1369,7 @@ async function autoRenameChannel(message, chatSessionRepo, titleGenerator, chann
 /**
  * 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) {
+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) {
     const commandName = interaction.commandName;
     const getAccountPort = (accountName) => {
         const match = antigravityAccounts.find((account) => account.name === accountName);
@@ -1476,6 +1493,11 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
                         '`/help` — Show this help',
                     ].join('\n')
                 },
+                {
+                    name: '📂 Artifacts', value: [
+                        '`/artifacts` — Browse and render generated artifacts from the active session',
+                    ].join('\n')
+                },
             ];
             const helpOutputFormat = userPrefRepo?.getOutputFormat(interaction.user.id) ?? 'embed';
             if (helpOutputFormat === 'plain') {
@@ -1828,6 +1850,14 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             await interaction.editReply({ content: codeBlock });
             break;
         }
+        case 'artifacts': {
+            await (0, artifactsUi_1.sendArtifactPickerUI)(interaction, {
+                userPrefRepo,
+                chatSessionRepo,
+                artifactService
+            });
+            break;
+        }
         default:
             await interaction.editReply({
                 content: `Unknown command: /${commandName}`,

package/dist/commands/registerSlashCommands.js

@@ -148,6 +148,10 @@ const logsCommand = new discord_js_1.SlashCommandBuilder()
 const pingCommand = new discord_js_1.SlashCommandBuilder()
     .setName('ping')
     .setDescription((0, i18n_1.t)('Check bot latency'));
+/** /artifacts command definition */
+const artifactsCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('artifacts')
+    .setDescription((0, i18n_1.t)('Browse and view generated artifacts from the active session'));
 /** Array of commands to register */
 exports.slashCommands = [
     helpCommand,
@@ -168,6 +172,7 @@ exports.slashCommands = [
     outputCommand,
     pingCommand,
     logsCommand,
+    artifactsCommand,
 ];
 /**
  * Register slash commands with Discord

package/dist/database/artifactThreadRepository.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactThreadRepository = void 0;
+/**
+ * Repository for mapping (channel_id, conversation_id, filename) to Discord thread ID.
+ * This allows reusing the same thread for multiple renders of the same file.
+ */
+class ArtifactThreadRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    initialize() {
+        const tableInfo = this.db.prepare("PRAGMA table_info('artifact_threads')").all();
+        if (tableInfo.length === 0) {
+            this.db.exec(`
+                CREATE TABLE artifact_threads (
+                    channel_id TEXT NOT NULL,
+                    conversation_id TEXT NOT NULL,
+                    filename TEXT NOT NULL,
+                    thread_id TEXT NOT NULL,
+                    PRIMARY KEY (channel_id, conversation_id, filename)
+                )
+            `);
+        }
+        else {
+            const hasConvId = tableInfo.some(col => col.name === 'conversation_id');
+            if (!hasConvId) {
+                // To safely migrate in sqlite, we recreate the table, since we need to change the primary key
+                this.db.exec(`
+                    CREATE TABLE artifact_threads_new (
+                        channel_id TEXT NOT NULL,
+                        conversation_id TEXT NOT NULL DEFAULT '',
+                        filename TEXT NOT NULL,
+                        thread_id TEXT NOT NULL,
+                        PRIMARY KEY (channel_id, conversation_id, filename)
+                    );
+                    INSERT INTO artifact_threads_new (channel_id, conversation_id, filename, thread_id)
+                    SELECT channel_id, '', filename, thread_id FROM artifact_threads;
+                    DROP TABLE artifact_threads;
+                    ALTER TABLE artifact_threads_new RENAME TO artifact_threads;
+                `);
+            }
+        }
+    }
+    /**
+     * Get the stored thread ID for a specific file in a channel and conversation.
+     */
+    getThreadId(channelId, conversationId, filename) {
+        const row = this.db.prepare('SELECT thread_id FROM artifact_threads WHERE channel_id = ? AND conversation_id = ? AND filename = ?').get(channelId, conversationId, filename);
+        return row?.thread_id ?? null;
+    }
+    /**
+     * Set the thread ID for a specific file in a channel and conversation.
+     */
+    setThreadId(channelId, conversationId, filename, threadId) {
+        this.db.prepare(`
+            INSERT OR REPLACE INTO artifact_threads (channel_id, conversation_id, filename, thread_id)
+            VALUES (?, ?, ?, ?)
+        `).run(channelId, conversationId, filename, threadId);
+    }
+    /**
+     * Remove a stored thread ID.
+     */
+    deleteThreadId(channelId, conversationId, filename) {
+        this.db.prepare('DELETE FROM artifact_threads WHERE channel_id = ? AND conversation_id = ? AND filename = ?').run(channelId, conversationId, filename);
+    }
+}
+exports.ArtifactThreadRepository = ArtifactThreadRepository;

package/dist/database/userPreferenceRepository.js

@@ -25,6 +25,7 @@ class UserPreferenceRepository {
             )
         `);
         this.migrateDefaultModel();
+        this.migrateArtifactRenderMode();
     }
     /**
      * Safe migration: add default_model column if it does not exist.
@@ -48,6 +49,16 @@ class UserPreferenceRepository {
             }
         }
     }
+    /**
+     * Migration: add artifact_render_mode column.
+     * Default is 'thread'.
+     */
+    migrateArtifactRenderMode() {
+        const columns = this.db.pragma('table_info(user_preferences)');
+        if (!columns.some(c => c.name === 'artifact_render_mode')) {
+            this.db.exec("ALTER TABLE user_preferences ADD COLUMN artifact_render_mode TEXT DEFAULT 'thread'");
+        }
+    }
     /**
      * Get the output format preference for a user.
      * Returns 'embed' as default if no preference is stored.
@@ -78,6 +89,28 @@ class UserPreferenceRepository {
         const row = this.db.prepare('SELECT default_model FROM user_preferences WHERE user_id = ?').get(userId);
         return row?.default_model ?? null;
     }
+    /**
+     * Get the artifact render mode preference for a user.
+     * Returns 'thread' as default.
+     */
+    getArtifactRenderMode(userId) {
+        const row = this.db.prepare('SELECT artifact_render_mode FROM user_preferences WHERE user_id = ?').get(userId);
+        if (!row || row.artifact_render_mode === 'thread')
+            return 'thread';
+        return 'inline';
+    }
+    /**
+     * Set the artifact render mode preference (upsert).
+     */
+    setArtifactRenderMode(userId, mode) {
+        this.db.prepare(`
+            INSERT INTO user_preferences (user_id, artifact_render_mode)
+            VALUES (?, ?)
+            ON CONFLICT(user_id)
+            DO UPDATE SET artifact_render_mode = excluded.artifact_render_mode,
+                          updated_at = datetime('now')
+        `).run(userId, mode);
+    }
     /**
      * Set the default model for a user (upsert).
      * Pass null to clear the default.
@@ -111,6 +144,7 @@ class UserPreferenceRepository {
             defaultModel: row.default_model ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
+            artifactRenderMode: row.artifact_render_mode ?? 'thread',
         };
     }
 }

package/dist/events/interactionCreateHandler.js

@@ -12,10 +12,20 @@ const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
 const projectListUi_1 = require("../ui/projectListUi");
 const modeService_1 = require("../services/modeService");
 const sessionPickerUi_1 = require("../ui/sessionPickerUi");
+const artifactsUi_1 = require("../ui/artifactsUi");
+const artifactService_1 = require("../services/artifactService");
 const accountUtils_1 = require("../utils/accountUtils");
 const accountUi_1 = require("../ui/accountUi");
 function createInteractionCreateHandler(deps) {
-    const getParentChannelId = (interaction) => (0, accountUtils_1.inferParentScopeChannelId)(interaction.channelId, interaction.channel?.parentId ?? null);
+    const getParentChannelId = (interaction) => {
+        const channelId = interaction.channelId;
+        if (!channelId)
+            return null;
+        const parentId = 'channel' in interaction && interaction.channel && 'parentId' in interaction.channel
+            ? interaction.channel.parentId
+            : null;
+        return (0, accountUtils_1.inferParentScopeChannelId)(channelId, parentId);
+    };
     const getSessionAccountName = (channelId) => deps.chatSessionRepo?.findByChannelId(channelId)?.activeAccountName ?? null;
     const resolveSelectedAccount = (channelId, userId, parentChannelId) => (0, accountUtils_1.resolveScopedAccountName)({
         channelId,
@@ -664,6 +674,20 @@ function createInteractionCreateHandler(deps) {
                     }
                     return;
                 }
+                if (interaction.customId.startsWith(`${artifactsUi_1.ARTIFACT_THREAD_BTN}:`) || interaction.customId.startsWith(`${artifactsUi_1.ARTIFACT_INLINE_BTN}:`)) {
+                    const newMode = interaction.customId.startsWith(`${artifactsUi_1.ARTIFACT_THREAD_BTN}:`) ? 'thread' : 'inline';
+                    const passedConvId = interaction.customId.split(':')[1] || null;
+                    if (deps.userPrefRepo) {
+                        deps.userPrefRepo.setArtifactRenderMode(interaction.user.id, newMode);
+                    }
+                    await interaction.deferUpdate().catch(logger_1.logger.error);
+                    await (0, artifactsUi_1.sendArtifactPickerUI)(interaction, {
+                        userPrefRepo: deps.userPrefRepo,
+                        chatSessionRepo: deps.chatSessionRepo,
+                        artifactService: deps.artifactService
+                    }, true, passedConvId);
+                    return;
+                }
             }
             catch (error) {
                 logger_1.logger.error('Error during button interaction handling:', error);
@@ -817,6 +841,140 @@ function createInteractionCreateHandler(deps) {
             }
             return;
         }
+        if (interaction.isStringSelectMenu() && interaction.customId === artifactsUi_1.ARTIFACT_SELECT_ID) {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                await interaction.deferUpdate();
+            }
+            catch (deferError) {
+                if (deferError?.code === 10062 || deferError?.code === 40060) {
+                    logger_1.logger.warn('[ArtifactSelect] deferUpdate expired. Skipping.');
+                    return;
+                }
+                logger_1.logger.error('[ArtifactSelect] deferUpdate failed:', deferError);
+                return;
+            }
+            const selectedValue = interaction.values[0];
+            if (!selectedValue) {
+                await interaction.editReply({ content: 'No artifact selected.', components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                const artifactService = new artifactService_1.ArtifactService();
+                // Resolve the selected artifact by rescanning and matching the encoded value
+                const channelId = interaction.channelId;
+                const sessionTitle = deps.chatSessionRepo?.findByChannelId(channelId)?.displayName?.trim() ?? '';
+                let conversationId = sessionTitle ? artifactService.findConversationByTitle(sessionTitle) : null;
+                if (!conversationId)
+                    conversationId = artifactService.getLatestConversationWithArtifacts();
+                if (!conversationId) {
+                    await interaction.editReply({ content: '📂 No artifacts found.', components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    return;
+                }
+                const artifacts = artifactService.listArtifacts(conversationId);
+                const decoded = artifactService.decodeSelectValue(selectedValue, artifacts);
+                if (!decoded) {
+                    logger_1.logger.warn(`[ArtifactSelect] Could not decode value: ${selectedValue}`);
+                    await interaction.editReply({ content: '⚠️ Could not identify the selected artifact.', components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    return;
+                }
+                const content = artifactService.getArtifactContent(decoded.conversationId, decoded.filename);
+                if (!content) {
+                    await interaction.editReply({ content: '⚠️ Could not read artifact content.', components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    return;
+                }
+                // Get user render mode
+                const renderMode = deps.userPrefRepo?.getArtifactRenderMode(interaction.user.id) ?? 'thread';
+                let targetChannel = interaction.channel;
+                if (renderMode === 'thread' && deps.artifactThreadRepo && interaction.channel?.threads) {
+                    try {
+                        const existingThreadId = deps.artifactThreadRepo.getThreadId(channelId, conversationId, decoded.filename);
+                        let thread = null;
+                        if (existingThreadId) {
+                            try {
+                                thread = await interaction.client.channels.fetch(existingThreadId);
+                                if (thread && thread.archived) {
+                                    await thread.setArchived(false);
+                                }
+                            }
+                            catch (fetchError) {
+                                logger_1.logger.warn(`[ArtifactSelect] Could not fetch existing thread ${existingThreadId}:`, fetchError);
+                                deps.artifactThreadRepo.deleteThreadId(channelId, conversationId, decoded.filename);
+                            }
+                        }
+                        if (!thread) {
+                            // Create new thread from the prompt message
+                            const message = await interaction.editReply({
+                                content: `📂 **Artifact: ${decoded.filename}**\n*Creating thread for persistent viewing...*`,
+                                components: [],
+                                allowedMentions: { parse: [] }
+                            });
+                            thread = await message.startThread({
+                                name: `artifact: ${decoded.filename}`,
+                                autoArchiveDuration: 10080,
+                            });
+                            deps.artifactThreadRepo.setThreadId(channelId, conversationId, decoded.filename, thread.id);
+                            // Update the main message to link to the thread
+                            await interaction.editReply({
+                                content: `📂 **Artifact: ${decoded.filename}**\n*Thread created: <#${thread.id}>*`,
+                                components: [],
+                                allowedMentions: { parse: [] }
+                            }).catch(logger_1.logger.error);
+                        }
+                        else {
+                            // Reuse existing thread
+                            await interaction.editReply({
+                                content: `📂 **Artifact: ${decoded.filename}**\n*Updated in existing thread: <#${thread.id}>*`,
+                                components: [],
+                                allowedMentions: { parse: [] }
+                            }).catch(logger_1.logger.error);
+                            // Send a visual spacer to separate content
+                            const now = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                            await thread.send({ content: `─────────────────────────\n🔄 **Artifact Re-rendered at ${now}**`, allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                        }
+                        targetChannel = thread;
+                    }
+                    catch (threadError) {
+                        logger_1.logger.error('[ArtifactSelect] Thread creation/resume failed, falling back to inline:', threadError);
+                        await interaction.editReply({ content: `📂 **${decoded.filename}**`, components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    }
+                }
+                else {
+                    // Inline rendering
+                    await interaction.editReply({ content: `📂 **${decoded.filename}**`, components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                }
+                // Split into 2000-char chunks and send as follow-ups or thread messages
+                const MAX_CHUNK = 1990;
+                let remaining = content;
+                while (remaining.length > 0) {
+                    let chunk;
+                    if (remaining.length <= MAX_CHUNK) {
+                        chunk = remaining;
+                        remaining = '';
+                    }
+                    else {
+                        const splitAt = remaining.lastIndexOf('\n', MAX_CHUNK);
+                        chunk = splitAt > 0 ? remaining.slice(0, splitAt) : remaining.slice(0, MAX_CHUNK);
+                        remaining = remaining.slice(chunk.length).replace(/^\n/, '');
+                    }
+                    if (targetChannel && targetChannel.send) {
+                        await targetChannel.send({ content: chunk, allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    }
+                    else {
+                        await interaction.followUp({ content: chunk, allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+                    }
+                }
+                logger_1.logger.info(`[ArtifactSelect] Served artifact ${decoded.conversationId}/${decoded.filename} to channel=${channelId} (mode=${renderMode})`);
+            }
+            catch (error) {
+                logger_1.logger.error('[ArtifactSelect] Error serving artifact:', error);
+                await interaction.editReply({ content: '❌ Error reading artifact.', components: [], allowedMentions: { parse: [] } }).catch(logger_1.logger.error);
+            }
+            return;
+        }
         if (interaction.isStringSelectMenu() && (0, projectListUi_1.isProjectSelectId)(interaction.customId)) {
             if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
                 await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);

package/dist/events/messageCreateHandler.js

@@ -179,6 +179,7 @@ function createMessageCreateHandler(deps) {
                         channelManager: deps.channelManager,
                         titleGenerator: deps.titleGenerator,
                         userPrefRepo: deps.userPrefRepo,
+                        artifactService: deps.artifactService,
                         extractionMode: deps.config.extractionMode,
                         responseTimeoutMs: deps.config.responseTimeoutMs,
                     });
@@ -358,6 +359,7 @@ function createMessageCreateHandler(deps) {
                                     channelManager: deps.channelManager,
                                     titleGenerator: deps.titleGenerator,
                                     userPrefRepo: deps.userPrefRepo,
+                                    artifactService: deps.artifactService,
                                     extractionMode: deps.config.extractionMode,
                                     responseTimeoutMs: deps.config.responseTimeoutMs,
                                     onFullCompletion: settle,

package/dist/services/artifactService.js

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * Artifact Service — reads Antigravity artifacts from the local filesystem.
+ *
+ * Antigravity persists artifacts (implementation plans, tasks, walkthroughs)
+ * as Markdown files with companion `.metadata.json` files in:
+ *   %USERPROFILE%/.gemini/antigravity/brain/<conversation-id>/
+ *
+ * This service locates relevant conversations and surfaces their artifacts
+ * for the /artifacts Discord command.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactService = void 0;
+exports.artifactTypeLabel = artifactTypeLabel;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const ARTIFACT_TYPE_LABELS = {
+    ARTIFACT_TYPE_IMPLEMENTATION_PLAN: '📋 Plan',
+    ARTIFACT_TYPE_TASK: '✅ Task',
+    ARTIFACT_TYPE_WALKTHROUGH: '🚶 Walkthrough',
+    ARTIFACT_TYPE_OTHER: '📄 Other',
+};
+function artifactTypeLabel(type) {
+    return ARTIFACT_TYPE_LABELS[type] ?? '📄 Artifact';
+}
+// ---------------------------------------------------------------------------
+// ArtifactService
+// ---------------------------------------------------------------------------
+class ArtifactService {
+    brainBasePath;
+    constructor(brainBasePath) {
+        this.brainBasePath =
+            brainBasePath ??
+                path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
+    }
+    /**
+     * List all conversations in the brain directory (UUIDs).
+     */
+    listConversationIds() {
+        try {
+            if (!fs.existsSync(this.brainBasePath))
+                return [];
+            return fs.readdirSync(this.brainBasePath).filter((entry) => {
+                const full = path.join(this.brainBasePath, entry);
+                return (fs.statSync(full).isDirectory() &&
+                    /^[0-9a-f-]{36}$/.test(entry));
+            });
+        }
+        catch (err) {
+            logger_1.logger.warn(`[ArtifactService] Failed to list brain directory: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Read the .metadata.json file for a given artifact in a conversation.
+     */
+    readMetadata(conversationId, mdFilename) {
+        const metaPath = path.join(this.brainBasePath, conversationId, `${mdFilename}.metadata.json`);
+        try {
+            if (!fs.existsSync(metaPath))
+                return null;
+            const raw = fs.readFileSync(metaPath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all artifacts in a given conversation directory.
+     * An artifact must be a .md file with a companion .metadata.json.
+     */
+    listArtifacts(conversationId) {
+        const convDir = path.join(this.brainBasePath, conversationId);
+        try {
+            if (!fs.existsSync(convDir))
+                return [];
+            const entries = fs.readdirSync(convDir);
+            const artifacts = [];
+            for (const entry of entries) {
+                // Only look at .md files (not .metadata.json, .resolved, etc.)
+                if (!entry.endsWith('.md'))
+                    continue;
+                const meta = this.readMetadata(conversationId, entry);
+                if (!meta)
+                    continue; // Not a tracked artifact — skip
+                artifacts.push({
+                    conversationId,
+                    filename: entry,
+                    artifactType: meta.artifactType ?? 'ARTIFACT_TYPE_OTHER',
+                    summary: meta.summary,
+                    updatedAt: meta.updatedAt,
+                    version: meta.version,
+                    absolutePath: path.join(convDir, entry),
+                });
+            }
+            // Sort by updatedAt descending (most recent first)
+            artifacts.sort((a, b) => {
+                const ta = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+                const tb = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+                return tb - ta;
+            });
+            return artifacts;
+        }
+        catch (err) {
+            logger_1.logger.warn(`[ArtifactService] Failed to list artifacts for ${conversationId}: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Try to find a conversation UUID whose overview.txt contains the given session title.
+     * Returns the UUID or null if not found.
+     */
+    findConversationByTitle(title) {
+        if (!title || !title.trim())
+            return null;
+        const needle = title.trim().toLowerCase();
+        const ids = this.listConversationIds();
+        // Sort by directory mtime descending (most recent first)
+        const sortedIds = ids
+            .map((id) => {
+            const full = path.join(this.brainBasePath, id);
+            try {
+                return { id, mtime: fs.statSync(full).mtimeMs };
+            }
+            catch {
+                return { id, mtime: 0 };
+            }
+        })
+            .sort((a, b) => b.mtime - a.mtime)
+            .map(x => x.id);
+        for (const id of sortedIds) {
+            const overviewPath = path.join(this.brainBasePath, id, '.system_generated', 'logs', 'overview.txt');
+            try {
+                if (!fs.existsSync(overviewPath))
+                    continue;
+                // Only read the first 4KB to avoid huge files
+                let fd = null;
+                try {
+                    fd = fs.openSync(overviewPath, 'r');
+                    const buf = Buffer.alloc(4096);
+                    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+                    const header = buf.slice(0, bytesRead).toString('utf-8').toLowerCase();
+                    if (header.includes(needle)) {
+                        return id;
+                    }
+                }
+                finally {
+                    if (fd !== null)
+                        fs.closeSync(fd);
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        return null;
+    }
+    /**
+     * Return the conversation ID of the most recently modified conversation
+     * that has at least one artifact. Falls back to the most recent conversation
+     * overall if none have artifacts.
+     */
+    getLatestConversationWithArtifacts() {
+        const ids = this.listConversationIds();
+        if (ids.length === 0)
+            return null;
+        // Sort by directory mtime descending
+        const sorted = ids
+            .map((id) => {
+            const full = path.join(this.brainBasePath, id);
+            try {
+                return { id, mtime: fs.statSync(full).mtimeMs };
+            }
+            catch {
+                return { id, mtime: 0 };
+            }
+        })
+            .sort((a, b) => b.mtime - a.mtime);
+        // Find the first one that has artifacts
+        for (const { id } of sorted) {
+            if (this.listArtifacts(id).length > 0)
+                return id;
+        }
+        // Nothing has artifacts — return most recent anyway (caller handles empty list)
+        return sorted[0]?.id ?? null;
+    }
+    /**
+     * Read the markdown content of a specific artifact file.
+     * Returns null if the file cannot be read.
+     */
+    getArtifactContent(conversationId, filename) {
+        // Sanitize: prevent path traversal
+        const safe = path.basename(filename);
+        if (!safe.endsWith('.md'))
+            return null;
+        const filePath = path.join(this.brainBasePath, conversationId, safe);
+        try {
+            if (!fs.existsSync(filePath))
+                return null;
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            logger_1.logger.warn(`[ArtifactService] Failed to read artifact ${conversationId}/${safe}: ${err}`);
+            return null;
+        }
+    }
+    /**
+     * Encode conversationId and filename into a single string for Discord select menu values.
+     * We use a prefix 'art_', followed by a short slice of the conv ID, and the filename.
+     * Added a short hash of the filename to prevent collisions on long-filename truncation.
+     */
+    static encodeSelectValue(conversationId, filename) {
+        const shortConv = conversationId.replace(/-/g, '').slice(0, 12);
+        // Simple hash of the filename
+        let hash = 0;
+        for (let i = 0; i < filename.length; i++) {
+            hash = ((hash << 5) - hash) + filename.charCodeAt(i);
+            hash |= 0; // Convert to 32bit integer
+        }
+        const shortHash = Math.abs(hash).toString(36).slice(0, 4);
+        return `art_${shortConv}_${shortHash}_${filename}`;
+    }
+    /**
+     * Decode a select menu value back into conversationId and filename.
+     * Since we only have a slice of the conversationId, we must look it up
+     * in the provided list of artifacts.
+     */
+    decodeSelectValue(value, artifacts) {
+        if (!value.startsWith('art_'))
+            return null;
+        // Format: art_CONV_HASH_FILENAME
+        const parts = value.split('_');
+        if (parts.length < 4)
+            return null;
+        const shortConv = parts[1];
+        const filename = parts.slice(3).join('_'); // Filename might contain underscores
+        // Find the matching artifact in the current list
+        const found = artifacts.find(a => a.filename === filename &&
+            a.conversationId.replace(/-/g, '').startsWith(shortConv));
+        return found ? { conversationId: found.conversationId, filename: found.filename } : null;
+    }
+}
+exports.ArtifactService = ArtifactService;

package/dist/ui/artifactsUi.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Artifacts UI — Discord embed + select menu for the /artifacts command.
+ *
+ * Follows the same pattern as sessionPickerUi.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_INLINE_BTN = exports.ARTIFACT_THREAD_BTN = exports.ARTIFACT_SELECT_ID = void 0;
+exports.buildArtifactPickerUI = buildArtifactPickerUI;
+exports.sendArtifactsUI = sendArtifactsUI;
+exports.sendArtifactPickerUI = sendArtifactPickerUI;
+const discord_js_1 = require("discord.js");
+const artifactService_1 = require("../services/artifactService");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Custom ID for the artifact select menu */
+exports.ARTIFACT_SELECT_ID = 'artifact_select';
+/** Custom ID for the toggle buttons */
+exports.ARTIFACT_THREAD_BTN = 'artifact_mode_thread';
+exports.ARTIFACT_INLINE_BTN = 'artifact_mode_inline';
+/** Discord select menu option limit */
+const MAX_SELECT_OPTIONS = 25;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, max - 1) + '…';
+}
+function formatOptionDescription(artifact) {
+    const parts = [];
+    parts.push((0, artifactService_1.artifactTypeLabel)(artifact.artifactType));
+    if (artifact.summary) {
+        parts.push(truncate(artifact.summary, 60));
+    }
+    const combined = parts.join(' · ');
+    // Discord limits descriptions to 100 chars
+    return combined.length > 0 ? truncate(combined, 100) : undefined;
+}
+function formatUpdatedAt(iso) {
+    if (!iso)
+        return '';
+    try {
+        return new Date(iso).toLocaleString(undefined, {
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+    }
+    catch {
+        return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Discord-specific builder
+// ---------------------------------------------------------------------------
+/**
+ * Build the artifact picker embed + select menu components.
+ */
+function buildArtifactPickerUI(artifacts, conversationId, renderMode = 'thread') {
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('📂 Artifacts')
+        .setColor(0x5865F2)
+        .setTimestamp();
+    if (artifacts.length === 0) {
+        embed.setDescription('No artifacts found for the active session.');
+        return { embeds: [embed], components: [] };
+    }
+    const displayId = conversationId
+        ? conversationId.slice(0, 8) + '…'
+        : 'current session';
+    embed.setDescription(`**${artifacts.length}** artifact(s) found (conversation \`${displayId}\`)\n` +
+        'Select one to render its content below.');
+    const fields = artifacts.map((a) => ({
+        name: a.filename,
+        value: [
+            (0, artifactService_1.artifactTypeLabel)(a.artifactType),
+            a.summary ? `*${truncate(a.summary, 120)}*` : '',
+            a.updatedAt ? `🕐 v${a.version ?? '?'} · ${formatUpdatedAt(a.updatedAt)}` : '',
+        ].filter(Boolean).join('\n'),
+        inline: false,
+    }));
+    // Add summary fields (max 10 to avoid embed limit)
+    embed.addFields(...fields.slice(0, 10));
+    const pageItems = artifacts.slice(0, MAX_SELECT_OPTIONS);
+    const options = pageItems.map((a) => ({
+        label: truncate(a.filename, 100),
+        value: artifactService_1.ArtifactService.encodeSelectValue(a.conversationId, a.filename),
+        description: formatOptionDescription(a),
+    }));
+    const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+        .setCustomId(exports.ARTIFACT_SELECT_ID)
+        .setPlaceholder('Select an artifact to view…')
+        .addOptions(options);
+    const components = [
+        new discord_js_1.ActionRowBuilder().addComponents(selectMenu),
+    ];
+    // Add toggle button row
+    const toggleButton = new discord_js_1.ButtonBuilder();
+    if (renderMode === 'thread') {
+        toggleButton
+            .setCustomId(`${exports.ARTIFACT_INLINE_BTN}:${conversationId || ''}`)
+            .setLabel('💬 Switch to Inline')
+            .setStyle(discord_js_1.ButtonStyle.Secondary)
+            .setEmoji('💬');
+        embed.setFooter({ text: 'Output: Thread (one thread per file)' });
+    }
+    else {
+        toggleButton
+            .setCustomId(`${exports.ARTIFACT_THREAD_BTN}:${conversationId || ''}`)
+            .setLabel('📌 Switch to Thread')
+            .setStyle(discord_js_1.ButtonStyle.Primary)
+            .setEmoji('📌');
+        embed.setFooter({ text: 'Output: Inline' });
+    }
+    components.push(new discord_js_1.ActionRowBuilder().addComponents(toggleButton));
+    return { embeds: [embed], components };
+}
+// ---------------------------------------------------------------------------
+// Interaction sender
+// ---------------------------------------------------------------------------
+/**
+ * Send the artifacts picker UI as an editReply to a slash command interaction.
+ */
+async function sendArtifactsUI(interaction, artifacts, conversationId, renderMode = 'thread') {
+    const { embeds, components } = buildArtifactPickerUI(artifacts, conversationId, renderMode);
+    await interaction.editReply({ embeds, components });
+}
+/**
+ * Higher-level helper to send the artifact picker UI,
+ * automatically discovering artifacts for the current channel.
+ */
+async function sendArtifactPickerUI(interaction, deps, edit = false, resolvedConversationId) {
+    const artifactService = deps.artifactService || new artifactService_1.ArtifactService();
+    let conversationId = resolvedConversationId;
+    if (!conversationId) {
+        const session = deps.chatSessionRepo?.findByChannelId(interaction.channelId);
+        if (session) {
+            conversationId = session.conversationId ?? null;
+            // Fallback to title matching if ID is not in DB or doesn't match a real folder
+            if (!conversationId || !artifactService.listArtifacts(conversationId).length) {
+                const sessionTitle = session.displayName?.trim() ?? '';
+                const matchedId = sessionTitle ? artifactService.findConversationByTitle(sessionTitle) : null;
+                if (matchedId)
+                    conversationId = matchedId;
+            }
+            // Note: We do NOT fallback to getLatestConversationWithArtifacts() for managed sessions
+            // to avoid showing artifacts from other projects/chats.
+        }
+        else {
+            // Final fallback: latest overall (only for non-session channels)
+            conversationId = artifactService.getLatestConversationWithArtifacts();
+        }
+    }
+    if (!conversationId) {
+        const payload = { content: '📂 No artifacts found for this session.', components: [], ephemeral: true };
+        if (edit || interaction.deferred || interaction.replied)
+            await interaction.editReply(payload);
+        else
+            await interaction.reply(payload);
+        return;
+    }
+    // 2. List artifacts
+    const artifacts = artifactService.listArtifacts(conversationId);
+    if (artifacts.length === 0) {
+        const payload = { content: '📂 No artifacts found in this conversation.', components: [], ephemeral: true };
+        if (edit || interaction.deferred || interaction.replied)
+            await interaction.editReply(payload);
+        else
+            await interaction.reply(payload);
+        return;
+    }
+    // 3. Get user render mode pref
+    const renderMode = deps.userPrefRepo?.getArtifactRenderMode(interaction.user.id) ?? 'thread';
+    // 4. Build and send
+    const { embeds, components } = buildArtifactPickerUI(artifacts, conversationId, renderMode);
+    const payload = { embeds, components, ephemeral: true };
+    if (edit || interaction.deferred || interaction.replied)
+        await interaction.editReply(payload);
+    else
+        await interaction.reply(payload);
+}

package/dist/utils/lockfile.js

@@ -36,7 +36,7 @@ function acquireLock() {
     if (typeof process.getuid === 'function' && dirStat.uid !== process.getuid()) {
         throw new Error(`Lock directory is not owned by current user: ${LOCK_DIR}`);
     }
-    if ((dirStat.mode & 0o077) !== 0) {
+    if (process.platform !== 'win32' && (dirStat.mode & 0o077) !== 0) {
         throw new Error(`Lock directory has overly permissive permissions: ${LOCK_DIR}`);
     }
     // Check existing lock file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.7.1",
+  "version": "0.8.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": {
@@ -70,9 +70,10 @@
     "minimatch": "^10.2.1",
     "semantic-release": "^25.0.3",
     "ts-jest": "^29.4.6",
-    "ts-morph": "^27.0.2",
+    "ts-morph": "^28.0.0",
     "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
     "typescript": "^5.9.3",
-    "undici": "^7.22.0"
+    "undici": "^8.0.3"
   }
 }