lazy-gravity 0.6.2 → 0.7.1

package/dist/events/interactionCreateHandler.js

@@ -12,8 +12,92 @@ 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 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 getSessionAccountName = (channelId) => deps.chatSessionRepo?.findByChannelId(channelId)?.activeAccountName ?? null;
+    const resolveSelectedAccount = (channelId, userId, parentChannelId) => (0, accountUtils_1.resolveScopedAccountName)({
+        channelId,
+        userId,
+        sessionAccountName: getSessionAccountName(channelId),
+        parentChannelId,
+        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+        channelPrefRepo: deps.channelPrefRepo,
+        accountPrefRepo: deps.accountPrefRepo,
+        accounts: deps.antigravityAccounts,
+    });
+    const getChannelCdp = (channelId, userId) => (() => {
+        const workspacePath = deps.wsHandler.getWorkspaceForChannel(channelId);
+        if (workspacePath) {
+            const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+            return deps.bridge.pool.getConnected(projectName, resolveSelectedAccount(channelId, userId));
+        }
+        return deps.bridge.lastActiveWorkspace
+            ? deps.bridge.pool.getConnected(deps.bridge.lastActiveWorkspace, resolveSelectedAccount(channelId, userId))
+            : null;
+    })();
+    const ensureBoundSessionActive = async (channelId, userId, cdp) => {
+        const savedTitle = deps.chatSessionRepo?.findByChannelId(channelId)?.displayName?.trim() || '';
+        if (!savedTitle || savedTitle === (0, i18n_1.t)('(Untitled)') || !deps.chatSessionService) {
+            return { ok: true };
+        }
+        const current = await deps.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 deps.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 deps.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 };
+    };
     return async (interaction) => {
+        if (interaction.isAutocomplete()) {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.respond([]).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                if (interaction.commandName === 'project') {
+                    const subcommand = interaction.options.getSubcommand(false);
+                    const focused = interaction.options.getFocused(true);
+                    if (subcommand === 'account' && focused.name === 'name') {
+                        const names = (0, accountUtils_1.listAccountNames)(deps.antigravityAccounts);
+                        const currentAccount = resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction));
+                        const needle = String(focused.value || '').trim().toLowerCase();
+                        const choices = names
+                            .filter((name) => !needle || name.toLowerCase().includes(needle))
+                            .slice(0, 25)
+                            .map((name) => ({
+                            name: name === currentAccount ? `${name} (current)` : name,
+                            value: name,
+                        }));
+                        await interaction.respond(choices);
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('Autocomplete handling error:', error);
+            }
+            await interaction.respond([]).catch(logger_1.logger.error);
+            return;
+        }
         if (interaction.isButton()) {
             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);
@@ -31,7 +115,7 @@ function createInteractionCreateHandler(deps) {
                     }
                     const projectName = approvalAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const detector = projectName
-                        ? deps.bridge.pool.getApprovalDetector(projectName)
+                        ? deps.bridge.pool.getApprovalDetector(projectName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction)))
                         : undefined;
                     if (!detector) {
                         try {
@@ -101,7 +185,7 @@ function createInteractionCreateHandler(deps) {
                     }
                     const planWorkspaceDirName = planningAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const planDetector = planWorkspaceDirName
-                        ? deps.bridge.pool.getPlanningDetector(planWorkspaceDirName)
+                        ? deps.bridge.pool.getPlanningDetector(planWorkspaceDirName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction)))
                         : undefined;
                     if (!planDetector) {
                         try {
@@ -227,7 +311,7 @@ function createInteractionCreateHandler(deps) {
                     }
                     const errorWorkspaceDirName = errorPopupAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const errorDetector = errorWorkspaceDirName
-                        ? deps.bridge.pool.getErrorPopupDetector(errorWorkspaceDirName)
+                        ? deps.bridge.pool.getErrorPopupDetector(errorWorkspaceDirName, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction)))
                         : undefined;
                     if (!errorDetector) {
                         try {
@@ -377,7 +461,7 @@ function createInteractionCreateHandler(deps) {
                     }
                     const runCmdWorkspace = runCommandAction.projectName ?? deps.bridge.lastActiveWorkspace;
                     const runCmdDetector = runCmdWorkspace
-                        ? deps.bridge.pool.getRunCommandDetector(runCmdWorkspace)
+                        ? deps.bridge.pool.getRunCommandDetector(runCmdWorkspace, resolveSelectedAccount(interaction.channelId, interaction.user.id, getParentChannelId(interaction)))
                         : undefined;
                     if (!runCmdDetector) {
                         try {
@@ -446,11 +530,16 @@ function createInteractionCreateHandler(deps) {
                 }
                 if (interaction.customId === 'model_set_default_btn') {
                     await interaction.deferUpdate();
-                    const cdp = deps.getCurrentCdp(deps.bridge);
+                    const cdp = getChannelCdp(interaction.channelId, interaction.user.id);
                     if (!cdp) {
                         await interaction.followUp({ content: 'Not connected to CDP.', flags: discord_js_1.MessageFlags.Ephemeral });
                         return;
                     }
+                    const sessionReady = await ensureBoundSessionActive(interaction.channelId, interaction.user.id, cdp);
+                    if (!sessionReady.ok) {
+                        await interaction.followUp({ content: sessionReady.error, flags: discord_js_1.MessageFlags.Ephemeral });
+                        return;
+                    }
                     const currentModel = await cdp.getCurrentModel();
                     if (!currentModel) {
                         await interaction.followUp({ content: 'No current model detected.', flags: discord_js_1.MessageFlags.Ephemeral });
@@ -461,7 +550,7 @@ function createInteractionCreateHandler(deps) {
                         deps.userPrefRepo.setDefaultModel(interaction.user.id, currentModel);
                     }
                     await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
-                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        getCurrentCdp: () => getChannelCdp(interaction.channelId, interaction.user.id),
                         fetchQuota: async () => deps.bridge.quota.fetchQuota(),
                     });
                     await interaction.followUp({ content: `Default model set to **${currentModel}**.`, flags: discord_js_1.MessageFlags.Ephemeral });
@@ -469,12 +558,20 @@ function createInteractionCreateHandler(deps) {
                 }
                 if (interaction.customId === 'model_clear_default_btn') {
                     await interaction.deferUpdate();
+                    const cdp = getChannelCdp(interaction.channelId, interaction.user.id);
+                    if (cdp) {
+                        const sessionReady = await ensureBoundSessionActive(interaction.channelId, interaction.user.id, cdp);
+                        if (!sessionReady.ok) {
+                            await interaction.followUp({ content: sessionReady.error, flags: discord_js_1.MessageFlags.Ephemeral });
+                            return;
+                        }
+                    }
                     deps.modelService.setDefaultModel(null);
                     if (deps.userPrefRepo) {
                         deps.userPrefRepo.setDefaultModel(interaction.user.id, null);
                     }
                     await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
-                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        getCurrentCdp: () => getChannelCdp(interaction.channelId, interaction.user.id),
                         fetchQuota: async () => deps.bridge.quota.fetchQuota(),
                     });
                     await interaction.followUp({ content: 'Default model cleared.', flags: discord_js_1.MessageFlags.Ephemeral });
@@ -482,8 +579,16 @@ function createInteractionCreateHandler(deps) {
                 }
                 if (interaction.customId === 'model_refresh_btn') {
                     await interaction.deferUpdate();
+                    const cdp = getChannelCdp(interaction.channelId, interaction.user.id);
+                    if (cdp) {
+                        const sessionReady = await ensureBoundSessionActive(interaction.channelId, interaction.user.id, cdp);
+                        if (!sessionReady.ok) {
+                            await interaction.followUp({ content: sessionReady.error, flags: discord_js_1.MessageFlags.Ephemeral });
+                            return;
+                        }
+                    }
                     await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
-                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        getCurrentCdp: () => getChannelCdp(interaction.channelId, interaction.user.id),
                         fetchQuota: async () => deps.bridge.quota.fetchQuota(),
                     });
                     return;
@@ -491,18 +596,23 @@ function createInteractionCreateHandler(deps) {
                 if (interaction.customId.startsWith('model_btn_')) {
                     await interaction.deferUpdate();
                     const modelName = interaction.customId.replace('model_btn_', '');
-                    const cdp = deps.getCurrentCdp(deps.bridge);
+                    const cdp = getChannelCdp(interaction.channelId, interaction.user.id);
                     if (!cdp) {
                         await interaction.followUp({ content: 'Not connected to CDP.', flags: discord_js_1.MessageFlags.Ephemeral });
                         return;
                     }
+                    const sessionReady = await ensureBoundSessionActive(interaction.channelId, interaction.user.id, cdp);
+                    if (!sessionReady.ok) {
+                        await interaction.followUp({ content: sessionReady.error, flags: discord_js_1.MessageFlags.Ephemeral });
+                        return;
+                    }
                     const res = await cdp.setUiModel(modelName);
                     if (!res.ok) {
                         await interaction.followUp({ content: res.error || 'Failed to change model.', flags: discord_js_1.MessageFlags.Ephemeral });
                     }
                     else {
                         await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
-                            getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                            getCurrentCdp: () => getChannelCdp(interaction.channelId, interaction.user.id),
                             fetchQuota: async () => deps.bridge.quota.fetchQuota(),
                         });
                         await interaction.followUp({ content: `Model changed to **${res.model}**!`, flags: discord_js_1.MessageFlags.Ephemeral });
@@ -589,7 +699,7 @@ function createInteractionCreateHandler(deps) {
             try {
                 const selectedMode = interaction.values[0];
                 deps.modeService.setMode(selectedMode);
-                const cdp = deps.getCurrentCdp(deps.bridge);
+                const cdp = getChannelCdp(interaction.channelId, interaction.user.id);
                 if (cdp) {
                     const res = await cdp.setUiMode(selectedMode);
                     if (!res.ok) {
@@ -612,6 +722,75 @@ function createInteractionCreateHandler(deps) {
             }
             return;
         }
+        if (interaction.isStringSelectMenu() && interaction.customId === accountUi_1.ACCOUNT_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('[Account] deferUpdate expired. Skipping.');
+                    return;
+                }
+                logger_1.logger.error('[Account] deferUpdate failed:', deferError);
+                return;
+            }
+            try {
+                if (!deps.accountPrefRepo) {
+                    await interaction.followUp({
+                        content: 'Account preference service not available.',
+                        flags: discord_js_1.MessageFlags.Ephemeral,
+                    }).catch(logger_1.logger.error);
+                    return;
+                }
+                const selectedAccount = interaction.values[0];
+                const names = (0, accountUtils_1.listAccountNames)(deps.antigravityAccounts);
+                if (!selectedAccount || !names.includes(selectedAccount)) {
+                    await interaction.followUp({
+                        content: `⚠️ Unknown account: **${selectedAccount || 'N/A'}**`,
+                        flags: discord_js_1.MessageFlags.Ephemeral,
+                    }).catch(logger_1.logger.error);
+                    return;
+                }
+                deps.bridge.selectedAccountByChannel?.set(interaction.channelId, selectedAccount);
+                const currentSession = deps.chatSessionRepo?.findByChannelId(interaction.channelId);
+                if (currentSession) {
+                    deps.chatSessionRepo?.setActiveAccountName(interaction.channelId, selectedAccount);
+                }
+                else {
+                    deps.accountPrefRepo.setAccountName(interaction.user.id, selectedAccount);
+                    deps.channelPrefRepo?.setAccountName(interaction.channelId, selectedAccount);
+                }
+                const channelWorkspace = deps.wsHandler.getWorkspaceForChannel(interaction.channelId);
+                const selectedPort = deps.antigravityAccounts?.find((a) => a.name === selectedAccount)?.cdpPort;
+                logger_1.logger.info(`[AccountSwitch] source=select channel=${interaction.channelId} user=${interaction.user.id} ` +
+                    `account=${selectedAccount} port=${selectedPort ?? 'unknown'} ` +
+                    `workspace=${channelWorkspace ?? 'unbound'}`);
+                await (0, accountUi_1.sendAccountUI)({ editReply: async (data) => await interaction.editReply(data) }, selectedAccount, names);
+                await interaction.followUp({
+                    content: `✅ Switched session account to **${selectedAccount}**.`,
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                }).catch(logger_1.logger.error);
+            }
+            catch (error) {
+                logger_1.logger.error('Error during account dropdown handling:', error);
+                try {
+                    if (interaction.deferred || interaction.replied) {
+                        await interaction.followUp({
+                            content: 'An error occurred while switching account.',
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        }).catch(logger_1.logger.error);
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.error('Failed to send error message:', e);
+                }
+            }
+            return;
+        }
         if (interaction.isStringSelectMenu() && (0, sessionPickerUi_1.isSessionSelectId)(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);
@@ -648,6 +827,7 @@ function createInteractionCreateHandler(deps) {
                 return;
             }
             try {
+                await interaction.deferUpdate();
                 await deps.wsHandler.handleSelectMenu(interaction, interaction.guild);
             }
             catch (error) {
@@ -681,10 +861,11 @@ function createInteractionCreateHandler(deps) {
             throw deferError;
         }
         try {
-            await deps.handleSlashInteraction(commandInteraction, deps.slashCommandHandler, deps.bridge, deps.wsHandler, deps.chatHandler, deps.cleanupHandler, deps.modeService, deps.modelService, deps.bridge.autoAccept, deps.client);
+            await deps.handleSlashInteraction(commandInteraction, deps.slashCommandHandler, deps.bridge, deps.wsHandler, deps.chatHandler, deps.cleanupHandler, deps.modeService, deps.modelService, deps.bridge.autoAccept, deps.client, deps.accountPrefRepo, deps.channelPrefRepo, deps.antigravityAccounts, deps.chatSessionRepo);
         }
         catch (error) {
-            logger_1.logger.error('Error during slash command handling:', error);
+            logger_1.logger.error(`[SlashCommand] command=${commandInteraction.commandName} channel=${commandInteraction.channelId} ` +
+                `user=${commandInteraction.user.id} failed:`, error);
             try {
                 await commandInteraction.editReply({ content: 'An error occurred while processing the command.' });
             }

package/dist/events/messageCreateHandler.js

@@ -8,6 +8,7 @@ const wrappers_1 = require("../platform/discord/wrappers");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const modeService_1 = require("../services/modeService");
 const imageHandler_1 = require("../utils/imageHandler");
+const accountUtils_1 = require("../utils/accountUtils");
 const logger_1 = require("../utils/logger");
 function createMessageCreateHandler(deps) {
     const getCurrentCdp = deps.getCurrentCdp ?? cdpBridgeManager_1.getCurrentCdp;
@@ -20,6 +21,15 @@ function createMessageCreateHandler(deps) {
     const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
     const cleanupInboundImageAttachments = deps.cleanupInboundImageAttachments ?? imageHandler_1.cleanupInboundImageAttachments;
     const isImageAttachment = deps.isImageAttachment ?? imageHandler_1.isImageAttachment;
+    const getParentChannelId = (message) => {
+        const parentId = message.channel?.parentId;
+        return typeof parentId === 'string' && parentId.length > 0 ? parentId : null;
+    };
+    const getAccountPort = (accountName) => {
+        const match = (deps.antigravityAccounts ?? []).find((account) => account.name === accountName);
+        return match ? match.cdpPort : null;
+    };
+    const getSessionAccountName = (channelId) => deps.chatSessionRepo.findByChannelId(channelId)?.activeAccountName ?? null;
     // Per-workspace prompt queue: serializes send→response cycles
     const workspaceQueues = new Map();
     const workspaceQueueDepths = new Map();
@@ -58,10 +68,25 @@ function createMessageCreateHandler(deps) {
             if (parsed.commandName === 'status') {
                 const activeNames = deps.bridge.pool.getActiveWorkspaceNames();
                 const currentMode = deps.modeService.getCurrentMode();
+                const session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                const currentAccount = (0, accountUtils_1.resolveScopedAccountName)({
+                    channelId: message.channelId,
+                    userId: message.author.id,
+                    sessionAccountName: getSessionAccountName(message.channelId),
+                    parentChannelId: getParentChannelId(message),
+                    selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+                    channelPrefRepo: deps.channelPrefRepo,
+                    accountPrefRepo: deps.accountPrefRepo,
+                    accounts: deps.antigravityAccounts,
+                });
+                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: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true },
+                    { name: 'Active Account', value: currentAccount, inline: true },
+                    { name: 'Original Account', value: session?.originAccountName ?? '(unset)', inline: true },
+                    { name: 'Conversation Title', value: conversationTitle, inline: false },
                 ];
                 let statusDescription = '';
                 if (activeNames.length > 0) {
@@ -97,6 +122,43 @@ function createMessageCreateHandler(deps) {
                 await message.reply({ embeds: [embed] });
                 return;
             }
+            if (parsed.commandName === 'account') {
+                const accountNames = (0, accountUtils_1.listAccountNames)(deps.antigravityAccounts);
+                const requested = parsed.args?.[0];
+                if (!requested) {
+                    const current = (0, accountUtils_1.resolveScopedAccountName)({
+                        channelId: message.channelId,
+                        userId: message.author.id,
+                        sessionAccountName: getSessionAccountName(message.channelId),
+                        parentChannelId: getParentChannelId(message),
+                        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+                        channelPrefRepo: deps.channelPrefRepo,
+                        accountPrefRepo: deps.accountPrefRepo,
+                        accounts: deps.antigravityAccounts,
+                    });
+                    await message.reply(`Current account: **${current}**\nAvailable: ${accountNames.join(', ')}`).catch(() => { });
+                    return;
+                }
+                if (!accountNames.includes(requested)) {
+                    await message.reply(`⚠️ Unknown account: **${requested}**`).catch(() => { });
+                    return;
+                }
+                deps.bridge.selectedAccountByChannel?.set(message.channelId, requested);
+                const currentSession = deps.chatSessionRepo.findByChannelId(message.channelId);
+                if (currentSession) {
+                    deps.chatSessionRepo.setActiveAccountName(message.channelId, requested);
+                }
+                else {
+                    deps.accountPrefRepo?.setAccountName(message.author.id, requested);
+                    deps.channelPrefRepo?.setAccountName(message.channelId, requested);
+                }
+                const channelWorkspace = deps.wsHandler.getWorkspaceForChannel(message.channelId);
+                logger_1.logger.info(`[AccountSwitch] source=text channel=${message.channelId} user=${message.author.id} ` +
+                    `account=${requested} port=${getAccountPort(requested) ?? 'unknown'} ` +
+                    `workspace=${channelWorkspace ?? 'unbound'}`);
+                await message.reply(`✅ Switched session account to **${requested}**.`).catch(() => { });
+                return;
+            }
             const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup', 'join', 'mirror', 'output'];
             if (slashOnlyCommands.includes(parsed.commandName)) {
                 await message.reply({
@@ -163,17 +225,48 @@ function createMessageCreateHandler(deps) {
                             await message.reactions.resolve('⏳')?.users.remove(botId).catch(() => { });
                         }
                         try {
-                            const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
+                            const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+                                channelId: message.channelId,
+                                userId: message.author.id,
+                                sessionAccountName: getSessionAccountName(message.channelId),
+                                parentChannelId: getParentChannelId(message),
+                                selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+                                channelPrefRepo: deps.channelPrefRepo,
+                                accountPrefRepo: deps.accountPrefRepo,
+                                accounts: deps.antigravityAccounts,
+                            });
+                            const selectedPort = getAccountPort(selectedAccount);
+                            deps.bridge.selectedAccountByChannel?.set(message.channelId, selectedAccount);
+                            logger_1.logger.info(`[Route] channel=${message.channelId} user=${message.author.id} ` +
+                                `project=${projectLabel} account=${selectedAccount} ` +
+                                `port=${selectedPort ?? 'unknown'} workspacePath=${workspacePath}`);
+                            const previousPreferredAccount = deps.bridge.pool.getPreferredAccountForWorkspace?.(workspacePath) ?? null;
+                            const cdp = await deps.bridge.pool.getOrConnect(workspacePath, { name: selectedAccount });
                             const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+                            deps.bridge.pool.setPreferredAccountForWorkspace?.(workspacePath, selectedAccount);
                             deps.bridge.lastActiveWorkspace = projectName;
                             const platformChannel = (0, wrappers_1.wrapDiscordChannel)(message.channel);
                             deps.bridge.lastActiveChannel = platformChannel;
                             registerApprovalWorkspaceChannel(deps.bridge, projectName, platformChannel);
-                            ensureApprovalDetector(deps.bridge, cdp, projectName);
-                            ensureErrorPopupDetector(deps.bridge, cdp, projectName);
-                            ensurePlanningDetector(deps.bridge, cdp, projectName);
-                            ensureRunCommandDetector(deps.bridge, cdp, projectName);
-                            const session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            ensureApprovalDetector(deps.bridge, cdp, projectName, selectedAccount);
+                            ensureErrorPopupDetector(deps.bridge, cdp, projectName, selectedAccount);
+                            ensurePlanningDetector(deps.bridge, cdp, projectName, selectedAccount);
+                            ensureRunCommandDetector(deps.bridge, cdp, projectName, selectedAccount);
+                            let session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            const staleSessionAccount = session?.isRenamed
+                                && ((session.activeAccountName && session.activeAccountName !== selectedAccount)
+                                    || (!session.activeAccountName && previousPreferredAccount && previousPreferredAccount !== selectedAccount));
+                            if (session && staleSessionAccount) {
+                                logger_1.logger.info(`[SessionAccountReset] channel=${message.channelId} ` +
+                                    `project=${projectName} oldAccount=${session.activeAccountName ?? previousPreferredAccount ?? 'unknown'} ` +
+                                    `newAccount=${selectedAccount}`);
+                                deps.chatSessionRepo.setActiveAccountName?.(message.channelId, selectedAccount);
+                                session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            }
+                            if (session) {
+                                deps.chatSessionRepo.setActiveAccountName?.(message.channelId, selectedAccount);
+                                deps.chatSessionRepo.initializeOriginAccountName?.(message.channelId, selectedAccount);
+                            }
                             if (session?.displayName) {
                                 registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, platformChannel);
                             }
@@ -198,6 +291,8 @@ function createMessageCreateHandler(deps) {
                                                     `"${session.displayName}" -> "${recoveredTitle}" ` +
                                                     `(channel: ${message.channelId})`);
                                                 deps.chatSessionRepo.updateDisplayName(message.channelId, recoveredTitle);
+                                                deps.chatSessionRepo.setActiveAccountName?.(message.channelId, selectedAccount);
+                                                deps.chatSessionRepo.initializeOriginAccountName?.(message.channelId, selectedAccount);
                                                 registerApprovalSessionChannel(deps.bridge, projectName, recoveredTitle, platformChannel);
                                             }
                                             activationResult = retryResult;
@@ -290,7 +385,8 @@ function createMessageCreateHandler(deps) {
                     });
                 }
                 else {
-                    await message.reply('No project is configured for this channel. Please create or select one with `/project`.');
+                    await message.reply('No project is configured for this channel. Use `/project` to bind one, ' +
+                        'or `/project reopen` if this is a previously used session.');
                 }
             }
             finally {

package/dist/handlers/accountSelectAction.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccountSelectAction = createAccountSelectAction;
+const accountUtils_1 = require("../utils/accountUtils");
+const accountUi_1 = require("../ui/accountUi");
+const logger_1 = require("../utils/logger");
+function createAccountSelectAction(deps) {
+    return {
+        match(customId) {
+            return customId === accountUi_1.ACCOUNT_SELECT_ID;
+        },
+        async execute(interaction, values) {
+            const selectedAccount = values[0];
+            if (!selectedAccount)
+                return;
+            const names = (0, accountUtils_1.listAccountNames)(deps.antigravityAccounts);
+            if (!names.includes(selectedAccount)) {
+                await interaction.followUp({
+                    text: `⚠️ Unknown account: **${selectedAccount}**`,
+                }).catch(() => { });
+                return;
+            }
+            await interaction.deferUpdate();
+            deps.bridge.selectedAccountByChannel?.set(interaction.channel.id, selectedAccount);
+            const currentSession = deps.chatSessionRepo?.findByChannelId(interaction.channel.id);
+            if (currentSession) {
+                deps.chatSessionRepo?.setActiveAccountName(interaction.channel.id, selectedAccount);
+            }
+            else {
+                deps.accountPrefRepo.setAccountName(interaction.user.id, selectedAccount);
+                deps.channelPrefRepo?.setAccountName(interaction.channel.id, selectedAccount);
+            }
+            const channelWorkspace = deps.getWorkspacePathForChannel?.(interaction.channel.id) ?? null;
+            const selectedPort = deps.antigravityAccounts.find((a) => a.name === selectedAccount)?.cdpPort;
+            logger_1.logger.info(`[AccountSwitch] source=select channel=${interaction.channel.id} user=${interaction.user.id} ` +
+                `account=${selectedAccount} port=${selectedPort ?? 'unknown'} ` +
+                `workspace=${channelWorkspace ?? 'unbound'}`);
+            const payload = (0, accountUi_1.buildAccountPayload)(selectedAccount, names);
+            await interaction.update(payload);
+            await interaction.followUp({
+                text: `✅ Switched session account to **${selectedAccount}**.`,
+            }).catch(() => { });
+        },
+    };
+}

package/dist/handlers/modelButtonAction.js

@@ -32,9 +32,17 @@ function createModelButtonAction(deps) {
             await interaction.deferUpdate();
             const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(deps.bridge);
             if (!cdp) {
+                logger_1.logger.warn(`[ModelCommand] source=button user=${interaction.user.id} action=${params.action} cdp=unavailable`);
                 await interaction.followUp({ text: 'Not connected to CDP.' }).catch(() => { });
                 return;
             }
+            if (deps.ensureSessionActivated) {
+                const sessionReady = await deps.ensureSessionActivated(interaction.channel.id, interaction.user.id, cdp);
+                if (!sessionReady.ok) {
+                    await interaction.followUp({ text: sessionReady.error }).catch(() => { });
+                    return;
+                }
+            }
             if (params.action === 'set_default') {
                 const currentModel = await cdp.getCurrentModel();
                 if (!currentModel) {
@@ -65,7 +73,12 @@ function createModelButtonAction(deps) {
                 }).catch(() => { });
             }
             else if (params.action === 'select') {
+                logger_1.logger.info(`[ModelCommand] source=button user=${interaction.user.id} target="${params.modelName}"`);
                 const res = await cdp.setUiModel(params.modelName);
+                logger_1.logger.info(`[ModelCommand] source=button user=${interaction.user.id} target="${params.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.followUp({
                         text: res.error || 'Failed to change model.',