lazy-gravity 0.6.2 → 0.7.1

package/dist/bot/index.js

@@ -38,6 +38,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startBot = exports.getResponseDeliveryModeForTest = void 0;
 exports.createSerialTaskQueueForTest = createSerialTaskQueueForTest;
+exports.handleSlashInteraction = handleSlashInteraction;
+const sessionPickerUi_1 = require("../ui/sessionPickerUi");
+const telegramJoinCommand_1 = require("./telegramJoinCommand");
 const i18n_1 = require("../utils/i18n");
 const logger_1 = require("../utils/logger");
 const logBuffer_1 = require("../utils/logBuffer");
@@ -51,7 +54,9 @@ const modeService_1 = require("../services/modeService");
 const modelService_1 = require("../services/modelService");
 const defaultModelApplicator_1 = require("../services/defaultModelApplicator");
 const templateRepository_1 = require("../database/templateRepository");
+const accountPreferenceRepository_1 = require("../database/accountPreferenceRepository");
 const workspaceBindingRepository_1 = require("../database/workspaceBindingRepository");
+const channelPreferenceRepository_1 = require("../database/channelPreferenceRepository");
 const chatSessionRepository_1 = require("../database/chatSessionRepository");
 const workspaceService_1 = require("../services/workspaceService");
 const workspaceCommandHandler_1 = require("../commands/workspaceCommandHandler");
@@ -60,6 +65,8 @@ const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
 const channelManager_1 = require("../services/channelManager");
 const titleGeneratorService_1 = require("../services/titleGeneratorService");
 const joinCommandHandler_1 = require("../commands/joinCommandHandler");
+// CDP integration services
+const cdpService_1 = require("../services/cdpService");
 const chatSessionService_1 = require("../services/chatSessionService");
 const responseMonitor_1 = require("../services/responseMonitor");
 const antigravityLauncher_1 = require("../services/antigravityLauncher");
@@ -74,9 +81,11 @@ const modeUi_1 = require("../ui/modeUi");
 const modelsUi_1 = require("../ui/modelsUi");
 const templateUi_1 = require("../ui/templateUi");
 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 userPreferenceRepository_1 = require("../database/userPreferenceRepository");
+const accountUtils_1 = require("../utils/accountUtils");
 const plainTextFormatter_1 = require("../utils/plainTextFormatter");
 const interactionCreateHandler_1 = require("../events/interactionCreateHandler");
 const messageCreateHandler_1 = require("../events/messageCreateHandler");
@@ -97,6 +106,8 @@ const modelButtonAction_1 = require("../handlers/modelButtonAction");
 const autoAcceptButtonAction_1 = require("../handlers/autoAcceptButtonAction");
 const templateButtonAction_1 = require("../handlers/templateButtonAction");
 const modeSelectAction_1 = require("../handlers/modeSelectAction");
+const accountSelectAction_1 = require("../handlers/accountSelectAction");
+const telegramStartupTarget_1 = require("./telegramStartupTarget");
 const channelManager_2 = require("../services/channelManager");
 /**
  * Normalize a candidate startup channel name for preference checks.
@@ -786,6 +797,8 @@ const startBot = async (cliLogLevel) => {
     const modelService = new modelService_1.ModelService();
     const templateRepo = new templateRepository_1.TemplateRepository(db);
     const userPrefRepo = new userPreferenceRepository_1.UserPreferenceRepository(db);
+    const accountPrefRepo = new accountPreferenceRepository_1.AccountPreferenceRepository(db);
+    const channelPrefRepo = new channelPreferenceRepository_1.ChannelPreferenceRepository(db);
     // Eagerly load default model from DB (single-user bot optimization)
     try {
         const firstUser = db.prepare('SELECT user_id FROM user_preferences LIMIT 1').get();
@@ -804,7 +817,11 @@ const startBot = async (cliLogLevel) => {
     // Auto-launch Antigravity with CDP port if not already running
     await (0, antigravityLauncher_1.ensureAntigravityRunning)();
     // Initialize CDP bridge (lazy connection: pool creation only)
-    const bridge = (0, cdpBridgeManager_1.initCdpBridge)(config.autoApproveFileEdits);
+    const accountPorts = Object.fromEntries((config.antigravityAccounts ?? []).map((account) => [account.name, account.cdpPort]));
+    const accountUserDataDirs = Object.fromEntries((config.antigravityAccounts ?? [])
+        .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);
     // Initialize CDP-dependent services (constructor CDP dependency removed)
     const chatSessionService = new chatSessionService_1.ChatSessionService();
     const titleGenerator = new titleGeneratorService_1.TitleGeneratorService();
@@ -815,8 +832,46 @@ const startBot = async (cliLogLevel) => {
         sendPromptImpl: sendPromptToAntigravity,
     });
     // Initialize command handlers (joinHandler is created after client, see below)
-    const wsHandler = new workspaceCommandHandler_1.WorkspaceCommandHandler(workspaceBindingRepo, chatSessionRepo, workspaceService, channelManager);
-    const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool);
+    const wsHandler = new workspaceCommandHandler_1.WorkspaceCommandHandler(workspaceBindingRepo, chatSessionRepo, workspaceService, channelManager, async (workspaceName, newChannelId, sourceChannelId, userId) => {
+        const workspacePath = workspaceService.getWorkspacePath(workspaceName);
+        const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+            channelId: sourceChannelId,
+            userId,
+            sessionAccountName: chatSessionRepo.findByChannelId(sourceChannelId)?.activeAccountName ?? null,
+            parentChannelId: null,
+            selectedAccountByChannel: bridge.selectedAccountByChannel,
+            channelPrefRepo,
+            accountPrefRepo,
+            accounts: config.antigravityAccounts,
+        });
+        chatSessionRepo.setActiveAccountName(newChannelId, selectedAccount);
+        bridge.selectedAccountByChannel?.set(newChannelId, selectedAccount);
+        bridge.pool.setPreferredAccountForWorkspace(workspacePath, selectedAccount);
+        const cdp = new cdpService_1.CdpService({
+            accountName: selectedAccount,
+            accountPorts,
+            accountUserDataDirs,
+            cdpCallTimeout: 15000,
+            maxReconnectAttempts: 0,
+        });
+        try {
+            await cdp.openWorkspace(workspacePath);
+        }
+        finally {
+            await cdp.disconnect().catch(() => { });
+        }
+        await bridge.pool.getOrConnect(workspacePath, { name: selectedAccount });
+    });
+    const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool, (channelId, userId) => (0, accountUtils_1.resolveScopedAccountName)({
+        channelId,
+        userId,
+        sessionAccountName: chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null,
+        parentChannelId: null,
+        selectedAccountByChannel: bridge.selectedAccountByChannel,
+        channelPrefRepo,
+        accountPrefRepo,
+        accounts: config.antigravityAccounts,
+    }));
     const cleanupHandler = new cleanupCommandHandler_1.CleanupCommandHandler(chatSessionRepo, workspaceBindingRepo);
     const slashCommandHandler = new slashCommandHandler_1.SlashCommandHandler(templateRepo);
     // Discord platform — only initialise the Discord client when the platform is enabled
@@ -834,7 +889,16 @@ const startBot = async (cliLogLevel) => {
                     discord_js_1.GatewayIntentBits.MessageContent,
                 ]
             });
-            const joinHandler = new joinCommandHandler_1.JoinCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, bridge.pool, workspaceService, client, config.extractionMode, config.responseTimeoutMs);
+            const joinHandler = new joinCommandHandler_1.JoinCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, bridge.pool, workspaceService, client, config.extractionMode, config.responseTimeoutMs, (channelId, userId) => (0, accountUtils_1.resolveScopedAccountName)({
+                channelId,
+                userId,
+                sessionAccountName: chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null,
+                parentChannelId: null,
+                selectedAccountByChannel: bridge.selectedAccountByChannel,
+                channelPrefRepo,
+                accountPrefRepo,
+                accounts: config.antigravityAccounts,
+            }));
             client.once(discord_js_1.Events.ClientReady, async (readyClient) => {
                 logger_1.logger.info(`Ready! Logged in as ${readyClient.user.tag} | extractionMode=${config.extractionMode}`);
                 try {
@@ -899,7 +963,12 @@ const startBot = async (cliLogLevel) => {
                 parseRunCommandCustomId: cdpBridgeManager_1.parseRunCommandCustomId,
                 joinHandler,
                 userPrefRepo,
-                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo),
+                accountPrefRepo,
+                channelPrefRepo,
+                chatSessionRepo,
+                chatSessionService,
+                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),
                 handleTemplateUse: async (interaction, templateId) => {
                     const template = templateRepo.findById(templateId);
                     if (!template) {
@@ -915,7 +984,18 @@ const startBot = async (cliLogLevel) => {
                     let cdp = null;
                     if (workspacePath) {
                         try {
-                            cdp = await bridge.pool.getOrConnect(workspacePath);
+                            const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+                                channelId,
+                                userId: interaction.user.id,
+                                sessionAccountName: chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null,
+                                parentChannelId: (0, accountUtils_1.inferParentScopeChannelId)(channelId, interaction.channel?.parentId ?? null),
+                                selectedAccountByChannel: bridge.selectedAccountByChannel,
+                                channelPrefRepo,
+                                accountPrefRepo,
+                                accounts: config.antigravityAccounts,
+                            });
+                            bridge.selectedAccountByChannel?.set(channelId, selectedAccount);
+                            cdp = await bridge.pool.getOrConnect(workspacePath, { name: selectedAccount });
                             const projectName = bridge.pool.extractProjectName(workspacePath);
                             bridge.lastActiveWorkspace = projectName;
                             const platformCh = (0, wrappers_1.wrapDiscordChannel)(interaction.channel);
@@ -925,10 +1005,10 @@ const startBot = async (cliLogLevel) => {
                             if (session?.displayName) {
                                 (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, session.displayName, platformCh);
                             }
-                            (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName);
-                            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName);
-                            (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName);
-                            (0, cdpBridgeManager_1.ensureRunCommandDetector)(bridge, cdp, projectName);
+                            (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName, selectedAccount);
+                            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName, selectedAccount);
+                            (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName, selectedAccount);
+                            (0, cdpBridgeManager_1.ensureRunCommandDetector)(bridge, cdp, projectName, selectedAccount);
                         }
                         catch (e) {
                             await interaction.followUp({
@@ -939,7 +1019,19 @@ const startBot = async (cliLogLevel) => {
                         }
                     }
                     else {
-                        cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                        const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+                            channelId,
+                            userId: interaction.user.id,
+                            sessionAccountName: chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null,
+                            parentChannelId: (0, accountUtils_1.inferParentScopeChannelId)(channelId, interaction.channel?.parentId ?? null),
+                            selectedAccountByChannel: bridge.selectedAccountByChannel,
+                            channelPrefRepo,
+                            accountPrefRepo,
+                            accounts: config.antigravityAccounts,
+                        });
+                        cdp = bridge.lastActiveWorkspace
+                            ? bridge.pool.getConnected(bridge.lastActiveWorkspace, selectedAccount)
+                            : null;
                     }
                     if (!cdp) {
                         await interaction.followUp({
@@ -992,6 +1084,9 @@ const startBot = async (cliLogLevel) => {
                 autoRenameChannel,
                 handleScreenshot: screenshotUi_1.handleScreenshot,
                 userPrefRepo,
+                accountPrefRepo,
+                channelPrefRepo,
+                antigravityAccounts: config.antigravityAccounts,
             }));
             await client.login(discordToken);
         } // end: else (credentials present)
@@ -1034,21 +1129,55 @@ const startBot = async (cliLogLevel) => {
                 botApi: telegramBot.api,
                 chatSessionService,
                 responseTimeoutMs: config.responseTimeoutMs,
+                accountPrefRepo,
+                channelPrefRepo,
+                antigravityAccounts: config.antigravityAccounts,
             });
             // Compose select handlers: project select + mode select
             const projectSelectHandler = (0, telegramProjectCommand_1.createTelegramSelectHandler)({
+                botApi: telegramBot.api,
+                bridge,
                 workspaceService,
                 telegramBindingRepo,
             });
             const modeSelectAction = (0, modeSelectAction_1.createModeSelectAction)({ bridge, modeService });
+            const accountSelectAction = (0, accountSelectAction_1.createAccountSelectAction)({
+                bridge,
+                accountPrefRepo,
+                channelPrefRepo,
+                chatSessionRepo,
+                antigravityAccounts: config.antigravityAccounts,
+                getWorkspacePathForChannel: (channelId) => {
+                    const binding = telegramBindingRepo.findByChatId(channelId);
+                    if (!binding)
+                        return null;
+                    return workspaceService
+                        ? workspaceService.getWorkspacePath(binding.workspacePath)
+                        : binding.workspacePath;
+                },
+            });
             const telegramSelectHandler = (0, selectHandler_1.createPlatformSelectHandler)({
                 actions: [
                     modeSelectAction,
+                    accountSelectAction,
                 ],
             });
             // Composite handler that routes to the right handler
             const compositeSelectHandler = async (interaction) => {
-                if (interaction.customId === 'mode_select') {
+                if (interaction.customId === sessionPickerUi_1.SESSION_SELECT_ID) {
+                    await (0, telegramJoinCommand_1.handleTelegramJoinSelect)({
+                        bridge,
+                        botApi: telegramBot.api,
+                        telegramBindingRepo,
+                        workspaceService,
+                        chatSessionService,
+                        accountPrefRepo,
+                        channelPrefRepo,
+                        antigravityAccounts: config.antigravityAccounts,
+                    }, interaction);
+                    return;
+                }
+                if (interaction.customId === 'mode_select' || interaction.customId === 'account_select') {
                     await telegramSelectHandler(interaction);
                     return;
                 }
@@ -1067,7 +1196,41 @@ const startBot = async (cliLogLevel) => {
                     (0, planningButtonAction_1.createPlanningButtonAction)({ bridge }),
                     (0, errorPopupButtonAction_1.createErrorPopupButtonAction)({ bridge }),
                     (0, runCommandButtonAction_1.createRunCommandButtonAction)({ bridge }),
-                    (0, modelButtonAction_1.createModelButtonAction)({ bridge, fetchQuota: () => bridge.quota.fetchQuota(), modelService, userPrefRepo }),
+                    (0, modelButtonAction_1.createModelButtonAction)({
+                        bridge,
+                        fetchQuota: () => bridge.quota.fetchQuota(),
+                        modelService,
+                        userPrefRepo,
+                        ensureSessionActivated: async (channelId, userId, cdp) => {
+                            const savedTitle = chatSessionRepo.findByChannelId(channelId)?.displayName?.trim() || '';
+                            if (!savedTitle || savedTitle === (0, i18n_1.t)('(Untitled)')) {
+                                return { ok: true };
+                            }
+                            const current = await chatSessionService.getCurrentSessionInfo(cdp);
+                            if (current.title.trim() === savedTitle) {
+                                return { ok: true };
+                            }
+                            logger_1.logger.info(`[ModelCommand] source=button channel=${channelId} user=${userId} ` +
+                                `restoringSession target="${savedTitle}" current="${current.title.trim() || '(unknown)'}"`);
+                            const activation = await chatSessionService.activateSessionByTitle(cdp, savedTitle, {
+                                maxWaitMs: 8000,
+                                retryIntervalMs: 300,
+                                allowVisibilityWarmupMs: 1000,
+                            });
+                            if (!activation.ok) {
+                                return {
+                                    ok: false,
+                                    error: `Failed to activate saved session "${savedTitle}" before model action: ${activation.error || 'unknown'}`,
+                                };
+                            }
+                            const refresh = await chatSessionService.refreshSessionViewIfStuck(cdp, savedTitle);
+                            if (!refresh.ok) {
+                                logger_1.logger.warn(`[ModelCommand] source=button channel=${channelId} user=${userId} ` +
+                                    `sessionRefreshWarning target="${savedTitle}" error="${refresh.error || 'unknown'}"`);
+                            }
+                            return { ok: true };
+                        },
+                    }),
                     (0, autoAcceptButtonAction_1.createAutoAcceptButtonAction)({ autoAcceptService: bridge.autoAccept }),
                     (0, templateButtonAction_1.createTemplateButtonAction)({ bridge, templateRepo }),
                 ],
@@ -1086,11 +1249,14 @@ const startBot = async (cliLogLevel) => {
                 { command: 'model', description: 'Switch LLM model' },
                 { command: 'screenshot', description: 'Capture Antigravity screenshot' },
                 { command: 'autoaccept', description: 'Toggle auto-accept mode' },
+                { command: 'account', description: 'Switch Antigravity account' },
                 { command: 'template', description: 'List prompt templates' },
                 { command: 'template_add', description: 'Add a prompt template' },
                 { command: 'template_delete', description: 'Delete a prompt template' },
                 { command: 'project_create', description: 'Create a new workspace' },
                 { command: 'new', description: 'Start a new chat session' },
+                { command: 'join', description: 'Take over an existing session' },
+                { command: 'mirror', description: 'Toggle PC-to-Telegram message mirroring' },
                 { command: 'logs', description: 'Show recent log entries' },
                 { command: 'stop', description: 'Interrupt active LLM generation' },
                 { command: 'help', description: 'Show available commands' },
@@ -1101,7 +1267,8 @@ const startBot = async (cliLogLevel) => {
             eventRouter.registerAdapter(telegramAdapter);
             await eventRouter.startAll();
             logger_1.logger.info(`Telegram bot started: @${botInfo.username} (${config.telegramAllowedUserIds?.length ?? 0} allowed users)`);
-            // Send startup message to all bound Telegram chats
+            // Send startup message to one Telegram target:
+            // prefer a group named "general", otherwise the first private chat.
             const bindings = telegramBindingRepo.findAll();
             if (bindings.length > 0) {
                 const os = await Promise.resolve().then(() => __importStar(require('os')));
@@ -1143,13 +1310,15 @@ const startBot = async (cliLogLevel) => {
                         }
                     }
                 };
-                const results = await Promise.allSettled(bindings.map((binding) => sendWithRetry(binding.chatId, startupText)));
-                const failed = results.filter((r) => r.status === 'rejected');
-                if (failed.length > 0) {
-                    logger_1.logger.warn(`[Telegram] Startup message failed for ${failed.length}/${bindings.length} chat(s) after retries: ${failed[0].reason?.message ?? 'unknown error'}`);
-                }
-                else {
-                    logger_1.logger.info(`Telegram startup message sent to ${bindings.length} bound chat(s).`);
+                const targetChatId = await (0, telegramStartupTarget_1.selectTelegramStartupChatId)(telegramBot.api, bindings);
+                if (targetChatId) {
+                    try {
+                        await sendWithRetry(targetChatId, startupText);
+                        logger_1.logger.info(`Telegram startup message sent to chat ${targetChatId}.`);
+                    }
+                    catch (error) {
+                        logger_1.logger.warn(`[Telegram] Startup message failed for chat ${targetChatId} after retries: ${error?.message ?? 'unknown error'}`);
+                    }
                 }
             }
         }
@@ -1183,8 +1352,78 @@ async function autoRenameChannel(message, chatSessionRepo, titleGenerator, chann
 /**
  * Handle Discord Interactions API slash commands
  */
-async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo, joinHandler, userPrefRepo) {
+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) {
     const commandName = interaction.commandName;
+    const getAccountPort = (accountName) => {
+        const match = antigravityAccounts.find((account) => account.name === accountName);
+        return match ? match.cdpPort : null;
+    };
+    const parentChannelId = (0, accountUtils_1.inferParentScopeChannelId)(interaction.channelId, interaction.channel?.parentId ?? null);
+    const getSessionAccountName = () => chatSessionRepo?.findByChannelId(interaction.channelId)?.activeAccountName ?? null;
+    const resolveSelectedAccount = () => (0, accountUtils_1.resolveScopedAccountName)({
+        channelId: interaction.channelId,
+        userId: interaction.user.id,
+        sessionAccountName: getSessionAccountName(),
+        parentChannelId,
+        selectedAccountByChannel: bridge.selectedAccountByChannel,
+        channelPrefRepo,
+        accountPrefRepo,
+        accounts: antigravityAccounts,
+    });
+    const getChannelWorkspacePath = () => wsHandler.getWorkspaceForChannel(interaction.channelId);
+    const getChannelCdp = () => (() => {
+        const workspacePath = getChannelWorkspacePath();
+        if (workspacePath) {
+            const projectName = bridge.pool.extractProjectName(workspacePath);
+            return bridge.pool.getConnected(projectName, resolveSelectedAccount());
+        }
+        return bridge.lastActiveWorkspace
+            ? bridge.pool.getConnected(bridge.lastActiveWorkspace, resolveSelectedAccount())
+            : null;
+    })();
+    const ensureChannelCdp = async () => {
+        const existing = getChannelCdp();
+        if (existing)
+            return existing;
+        const workspacePath = getChannelWorkspacePath();
+        if (!workspacePath)
+            return null;
+        try {
+            return await bridge.pool.getOrConnect(workspacePath, { name: resolveSelectedAccount() });
+        }
+        catch {
+            return null;
+        }
+    };
+    const ensureBoundSessionActive = async (cdp) => {
+        const savedTitle = chatSessionRepo?.findByChannelId(interaction.channelId)?.displayName?.trim() || '';
+        if (!savedTitle || savedTitle === (0, i18n_1.t)('(Untitled)')) {
+            return { ok: true };
+        }
+        const current = await chatSessionService.getCurrentSessionInfo(cdp);
+        if (current.title.trim() === savedTitle) {
+            return { ok: true };
+        }
+        logger_1.logger.info(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+            `restoringSession target="${savedTitle}" current="${current.title.trim() || '(unknown)'}"`);
+        const activation = await chatSessionService.activateSessionByTitle(cdp, savedTitle, {
+            maxWaitMs: 8000,
+            retryIntervalMs: 300,
+            allowVisibilityWarmupMs: 1000,
+        });
+        if (!activation.ok) {
+            return {
+                ok: false,
+                error: `Failed to activate saved session "${savedTitle}" before model action: ${activation.error || 'unknown'}`,
+            };
+        }
+        const refresh = await chatSessionService.refreshSessionViewIfStuck(cdp, savedTitle);
+        if (!refresh.ok) {
+            logger_1.logger.warn(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+                `sessionRefreshWarning target="${savedTitle}" error="${refresh.error || 'unknown'}"`);
+        }
+        return { ok: true };
+    };
     switch (commandName) {
         case 'help': {
             const helpFields = [
@@ -1217,6 +1456,7 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
                     name: '📁 Projects', value: [
                         '`/project` — Display project list',
                         '`/project create <name>` — Create a new project',
+                        '`/project account [name]` — Show or change the project channel account',
                     ].join('\n')
                 },
                 {
@@ -1230,6 +1470,7 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
                     name: '🔧 System', value: [
                         '`/status` — Display overall bot status',
                         '`/autoaccept` — Toggle auto-approve mode for approval dialogs via buttons',
+                        '`/account` — Show and switch Antigravity account',
                         '`/logs [lines] [level]` — View recent bot logs',
                         '`/cleanup [days]` — Clean up unused channels/categories',
                         '`/help` — Show this help',
@@ -1258,24 +1499,47 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             break;
         }
         case 'mode': {
-            await (0, modeUi_1.sendModeUI)(interaction, modeService, { getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge) });
+            await (0, modeUi_1.sendModeUI)(interaction, modeService, { getCurrentCdp: () => getChannelCdp() });
             break;
         }
         case 'model': {
             const modelName = interaction.options.getString('name');
+            logger_1.logger.info(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+                `requested=${modelName ? `"${modelName}"` : 'ui'}`);
             if (!modelName) {
+                const cdp = await ensureChannelCdp();
+                if (!cdp) {
+                    logger_1.logger.warn(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} cdp=unavailable`);
+                    await interaction.editReply({ content: 'Not connected to CDP.' });
+                    break;
+                }
+                const sessionReady = await ensureBoundSessionActive(cdp);
+                if (!sessionReady.ok) {
+                    await interaction.editReply({ content: sessionReady.error });
+                    break;
+                }
                 await (0, modelsUi_1.sendModelsUI)(interaction, {
-                    getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge),
+                    getCurrentCdp: () => cdp,
                     fetchQuota: async () => bridge.quota.fetchQuota(),
                 });
             }
             else {
-                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                const cdp = await ensureChannelCdp();
                 if (!cdp) {
+                    logger_1.logger.warn(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} target="${modelName}" cdp=unavailable`);
                     await interaction.editReply({ content: 'Not connected to CDP.' });
                     break;
                 }
+                const sessionReady = await ensureBoundSessionActive(cdp);
+                if (!sessionReady.ok) {
+                    await interaction.editReply({ content: sessionReady.error });
+                    break;
+                }
                 const res = await cdp.setUiModel(modelName);
+                logger_1.logger.info(`[ModelCommand] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+                    `target="${modelName}" ok=${res.ok} applied=${res.model ? `"${res.model}"` : 'null'} ` +
+                    `verified=${res.verified === true} alreadySelected=${res.alreadySelected === true} ` +
+                    `error=${res.error ? `"${res.error}"` : 'null'}`);
                 if (res.ok) {
                     await interaction.editReply({ content: `Model changed to **${res.model}**.` });
                 }
@@ -1315,19 +1579,26 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
         case 'status': {
             const activeNames = bridge.pool.getActiveWorkspaceNames();
             const currentModel = (() => {
-                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                const cdp = getChannelCdp();
                 return cdp ? 'CDP Connected' : 'Disconnected';
             })();
             const currentMode = modeService.getCurrentMode();
+            const session = chatSessionRepo?.findByChannelId(interaction.channelId);
             const mirroringWorkspaces = activeNames.filter((name) => bridge.pool.getUserMessageDetector(name)?.isActive());
             const mirrorStatus = mirroringWorkspaces.length > 0
                 ? `📡 ON (${mirroringWorkspaces.join(', ')})`
                 : '⚪ OFF';
+            const currentAccount = resolveSelectedAccount();
+            const originalAccount = session?.originAccountName ?? '(unset)';
+            const conversationTitle = session?.displayName ?? '(New chat / no saved title)';
             const statusFields = [
                 { name: 'CDP Connection', value: activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected', inline: true },
                 { name: 'Mode', value: modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode, inline: true },
                 { name: 'Auto Approve', value: autoAcceptService.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true },
                 { name: 'Mirroring', value: mirrorStatus, inline: true },
+                { name: 'Active Account', value: currentAccount, inline: true },
+                { name: 'Original Account', value: originalAccount, inline: true },
+                { name: 'Conversation Title', value: conversationTitle, inline: false },
             ];
             let statusDescription = '';
             if (activeNames.length > 0) {
@@ -1372,6 +1643,38 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             await interaction.editReply({ content: result.message });
             break;
         }
+        case 'account': {
+            if (!accountPrefRepo) {
+                await interaction.editReply({ content: 'Account preference service not available.' });
+                break;
+            }
+            const requested = interaction.options.getString('name');
+            if (!requested) {
+                const current = resolveSelectedAccount();
+                const names = (0, accountUtils_1.listAccountNames)(antigravityAccounts);
+                await (0, accountUi_1.sendAccountUI)(interaction, current, names);
+                break;
+            }
+            if (!(0, accountUtils_1.listAccountNames)(antigravityAccounts).includes(requested)) {
+                await interaction.editReply({ content: `⚠️ Unknown account: **${requested}**` });
+                break;
+            }
+            bridge.selectedAccountByChannel?.set(interaction.channelId, requested);
+            const currentSession = chatSessionRepo?.findByChannelId(interaction.channelId);
+            if (currentSession) {
+                chatSessionRepo?.setActiveAccountName(interaction.channelId, requested);
+            }
+            else {
+                accountPrefRepo.setAccountName(interaction.user.id, requested);
+                channelPrefRepo?.setAccountName(interaction.channelId, requested);
+            }
+            const channelWorkspace = wsHandler.getWorkspaceForChannel(interaction.channelId);
+            logger_1.logger.info(`[AccountSwitch] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+                `account=${requested} port=${getAccountPort(requested) ?? 'unknown'} ` +
+                `workspace=${channelWorkspace ?? 'unbound'}`);
+            await interaction.editReply({ content: `✅ Switched session account to **${requested}**.` });
+            break;
+        }
         case 'output': {
             if (!userPrefRepo) {
                 await interaction.editReply({ content: 'Output preference service not available.' });
@@ -1390,11 +1693,11 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
             break;
         }
         case 'screenshot': {
-            await (0, screenshotUi_1.handleScreenshot)(interaction, (0, cdpBridgeManager_1.getCurrentCdp)(bridge));
+            await (0, screenshotUi_1.handleScreenshot)(interaction, getChannelCdp());
             break;
         }
         case 'stop': {
-            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            const cdp = getChannelCdp();
             if (!cdp) {
                 await interaction.editReply({ content: '⚠️ Not connected to CDP. Please connect to a project first.' });
                 break;
@@ -1443,6 +1746,29 @@ async function handleSlashInteraction(interaction, handler, bridge, wsHandler, c
                 }
                 await wsHandler.handleCreate(interaction, interaction.guild);
             }
+            else if (wsSub === 'account') {
+                const requested = interaction.options.getString('name');
+                const names = (0, accountUtils_1.listAccountNames)(antigravityAccounts);
+                const currentProjectAccount = channelPrefRepo?.getAccountName(interaction.channelId) ?? null;
+                if (!requested) {
+                    await interaction.editReply({
+                        content: `Project channel account: **${currentProjectAccount ?? 'unset'}**\nAvailable: ${names.join(', ')}`,
+                    });
+                    break;
+                }
+                if (!names.includes(requested)) {
+                    await interaction.editReply({ content: `⚠️ Unknown account: **${requested}**` });
+                    break;
+                }
+                channelPrefRepo?.setAccountName(interaction.channelId, requested);
+                bridge.selectedAccountByChannel?.set(interaction.channelId, requested);
+                const channelWorkspace = wsHandler.getWorkspaceForChannel(interaction.channelId);
+                logger_1.logger.info(`[ProjectAccountSwitch] source=slash channel=${interaction.channelId} user=${interaction.user.id} ` +
+                    `account=${requested} port=${getAccountPort(requested) ?? 'unknown'} ` +
+                    `workspace=${channelWorkspace ?? 'unbound'}`);
+                await interaction.editReply({ content: `✅ Bound this project channel to account **${requested}**.` });
+                break;
+            }
             else {
                 // /project list or /project (default)
                 await wsHandler.handleShow(interaction);