disunday 1.0.0

package/dist/commands/login.js

@@ -0,0 +1,488 @@
+// /login command - Authenticate with AI providers (OAuth or API key).
+// Supports GitHub Copilot (device flow), OpenAI Codex (device flow), and API keys.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ModalSubmitInteraction, ChannelType, } from 'discord.js';
+import crypto from 'node:crypto';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const loginLogger = createLogger(LogPrefix.LOGIN);
+// Store context by hash to avoid customId length limits (Discord max: 100 chars)
+const pendingLoginContexts = new Map();
+/**
+ * Handle the /login slash command.
+ * Shows a select menu with available providers.
+ */
+export async function handleLoginCommand({ interaction, appId, }) {
+    loginLogger.log('[LOGIN] handleLoginCommand called');
+    // Defer reply immediately to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    loginLogger.log('[LOGIN] Deferred reply');
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    // Determine if we're in a thread or text channel
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = getDisundayMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = getDisundayMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({
+            content: 'This channel is not configured for this bot',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
+        const providersResponse = await getClient().provider.list({
+            query: { directory: projectDirectory },
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+            });
+            return;
+        }
+        const { all: allProviders, connected } = providersResponse.data;
+        if (allProviders.length === 0) {
+            await interaction.editReply({
+                content: 'No providers available.',
+            });
+            return;
+        }
+        // Store context with a short hash key to avoid customId length limits
+        const context = {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+        };
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingLoginContexts.set(contextHash, context);
+        const options = allProviders.slice(0, 25).map((provider) => {
+            const isConnected = connected.includes(provider.id);
+            return {
+                label: `${provider.name}${isConnected ? ' ✓' : ''}`.slice(0, 100),
+                value: provider.id,
+                description: isConnected ? 'Connected - select to re-authenticate' : 'Not connected',
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`login_provider:${contextHash}`)
+            .setPlaceholder('Select a provider to authenticate')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Authenticate with Provider**\nSelect a provider:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        loginLogger.error('Error loading providers:', error);
+        await interaction.editReply({
+            content: `Failed to load providers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+/**
+ * Handle the provider select menu interaction.
+ * Shows a second select menu with auth methods for the chosen provider.
+ */
+export async function handleLoginProviderSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_provider:')) {
+        return;
+    }
+    const contextHash = customId.replace('login_provider:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'Selection expired. Please run /login again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedProviderId = interaction.values[0];
+    if (!selectedProviderId) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'No provider selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        // Get provider info for display
+        const providersResponse = await getClient().provider.list({
+            query: { directory: context.dir },
+        });
+        const provider = providersResponse.data?.all.find((p) => p.id === selectedProviderId);
+        const providerName = provider?.name || selectedProviderId;
+        // Get auth methods for all providers
+        const authMethodsResponse = await getClient().provider.auth({
+            query: { directory: context.dir },
+        });
+        if (!authMethodsResponse.data) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: 'Failed to fetch authentication methods',
+                components: [],
+            });
+            return;
+        }
+        // Get methods for this specific provider, default to API key if none defined
+        const methods = authMethodsResponse.data[selectedProviderId] || [
+            { type: 'api', label: 'API Key' },
+        ];
+        if (methods.length === 0) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: `No authentication methods available for ${providerName}`,
+                components: [],
+            });
+            return;
+        }
+        // Update context with provider info
+        context.providerId = selectedProviderId;
+        context.providerName = providerName;
+        pendingLoginContexts.set(contextHash, context);
+        // If only one method and it's API, show modal directly (no defer)
+        if (methods.length === 1 && methods[0].type === 'api') {
+            const method = methods[0];
+            context.methodIndex = 0;
+            context.methodType = method.type;
+            context.methodLabel = method.label;
+            pendingLoginContexts.set(contextHash, context);
+            await showApiKeyModal(interaction, contextHash, providerName);
+            return;
+        }
+        // For OAuth or multiple methods, defer and continue
+        await interaction.deferUpdate();
+        // If only one method and it's OAuth, start flow directly
+        if (methods.length === 1) {
+            const method = methods[0];
+            context.methodIndex = 0;
+            context.methodType = method.type;
+            context.methodLabel = method.label;
+            pendingLoginContexts.set(contextHash, context);
+            await startOAuthFlow(interaction, context, contextHash);
+            return;
+        }
+        // Multiple methods - show selection menu
+        const options = methods.slice(0, 25).map((method, index) => ({
+            label: method.label.slice(0, 100),
+            value: String(index),
+            description: method.type === 'oauth' ? 'OAuth authentication' : 'Enter API key manually',
+        }));
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`login_method:${contextHash}`)
+            .setPlaceholder('Select authentication method')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Authenticate with ${providerName}**\nSelect authentication method:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        loginLogger.error('Error loading auth methods:', error);
+        if (!interaction.deferred && !interaction.replied) {
+            await interaction.deferUpdate();
+        }
+        await interaction.editReply({
+            content: `Failed to load auth methods: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle the auth method select menu interaction.
+ * Starts OAuth flow or shows API key modal.
+ */
+export async function handleLoginMethodSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_method:')) {
+        return;
+    }
+    const contextHash = customId.replace('login_method:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'Selection expired. Please run /login again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedMethodIndex = parseInt(interaction.values[0] || '0', 10);
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        // Get auth methods again to get the selected one
+        const authMethodsResponse = await getClient().provider.auth({
+            query: { directory: context.dir },
+        });
+        const methods = authMethodsResponse.data?.[context.providerId] || [
+            { type: 'api', label: 'API Key' },
+        ];
+        const selectedMethod = methods[selectedMethodIndex];
+        if (!selectedMethod) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: 'Invalid method selected',
+                components: [],
+            });
+            return;
+        }
+        // Update context
+        context.methodIndex = selectedMethodIndex;
+        context.methodType = selectedMethod.type;
+        context.methodLabel = selectedMethod.label;
+        pendingLoginContexts.set(contextHash, context);
+        if (selectedMethod.type === 'api') {
+            // Show API key modal (don't defer for modals)
+            await showApiKeyModal(interaction, contextHash, context.providerName);
+        }
+        else {
+            // Start OAuth flow
+            await interaction.deferUpdate();
+            await startOAuthFlow(interaction, context, contextHash);
+        }
+    }
+    catch (error) {
+        loginLogger.error('Error processing auth method:', error);
+        try {
+            if (!interaction.deferred && !interaction.replied) {
+                await interaction.deferUpdate();
+            }
+            await interaction.editReply({
+                content: `Failed to process auth method: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                components: [],
+            });
+        }
+        catch {
+            // Ignore follow-up errors
+        }
+    }
+}
+/**
+ * Show API key input modal.
+ */
+async function showApiKeyModal(interaction, contextHash, providerName) {
+    const modal = new ModalBuilder()
+        .setCustomId(`login_apikey:${contextHash}`)
+        .setTitle(`${providerName} API Key`.slice(0, 45));
+    const apiKeyInput = new TextInputBuilder()
+        .setCustomId('apikey')
+        .setLabel('API Key')
+        .setPlaceholder('sk-...')
+        .setStyle(TextInputStyle.Short)
+        .setRequired(true);
+    const actionRow = new ActionRowBuilder().addComponents(apiKeyInput);
+    modal.addComponents(actionRow);
+    await interaction.showModal(modal);
+}
+/**
+ * Start OAuth authorization flow.
+ */
+async function startOAuthFlow(interaction, context, contextHash) {
+    if (!context.providerId || context.methodIndex === undefined) {
+        await interaction.editReply({
+            content: 'Invalid context for OAuth flow',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        await interaction.editReply({
+            content: `**Authenticating with ${context.providerName}**\nStarting authorization...`,
+            components: [],
+        });
+        // Start OAuth authorization
+        const authorizeResponse = await getClient().provider.oauth.authorize({
+            path: { id: context.providerId },
+            body: { method: context.methodIndex },
+            query: { directory: context.dir },
+        });
+        if (!authorizeResponse.data) {
+            const errorData = authorizeResponse.error;
+            await interaction.editReply({
+                content: `Failed to start authorization: ${errorData?.data?.message || 'Unknown error'}`,
+                components: [],
+            });
+            return;
+        }
+        const { url, method, instructions } = authorizeResponse.data;
+        // Show authorization URL and instructions
+        let message = `**Authenticating with ${context.providerName}**\n\n`;
+        message += `Open this URL to authorize:\n${url}\n\n`;
+        if (instructions) {
+            // Extract code from instructions like "Enter code: ABC-123"
+            const codeMatch = instructions.match(/code[:\s]+([A-Z0-9-]+)/i);
+            if (codeMatch) {
+                message += `**Code:** \`${codeMatch[1]}\`\n\n`;
+            }
+            else {
+                message += `${instructions}\n\n`;
+            }
+        }
+        if (method === 'auto') {
+            message += '_Waiting for authorization to complete..._';
+        }
+        await interaction.editReply({
+            content: message,
+            components: [],
+        });
+        if (method === 'auto') {
+            // Poll for completion (device flow)
+            const callbackResponse = await getClient().provider.oauth.callback({
+                path: { id: context.providerId },
+                body: { method: context.methodIndex },
+                query: { directory: context.dir },
+            });
+            if (callbackResponse.error) {
+                const errorData = callbackResponse.error;
+                await interaction.editReply({
+                    content: `**Authentication Failed**\n${errorData?.data?.message || 'Authorization was not completed'}`,
+                    components: [],
+                });
+                return;
+            }
+            // Dispose to refresh provider state so new credentials are recognized
+            await getClient().instance.dispose({ query: { directory: context.dir } });
+            await interaction.editReply({
+                content: `✅ **Successfully authenticated with ${context.providerName}!**\n\nYou can now use models from this provider.`,
+                components: [],
+            });
+        }
+        // For 'code' method, we would need to prompt for code input
+        // But Discord modals can't be shown after deferUpdate, so we'd need a different flow
+        // For now, most providers use 'auto' (device flow) which works well for Discord
+        // Clean up context
+        pendingLoginContexts.delete(contextHash);
+    }
+    catch (error) {
+        loginLogger.error('OAuth flow error:', error);
+        await interaction.editReply({
+            content: `**Authentication Failed**\n${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle API key modal submission.
+ */
+export async function handleApiKeyModalSubmit(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_apikey:')) {
+        return;
+    }
+    await interaction.deferReply({ ephemeral: true });
+    const contextHash = customId.replace('login_apikey:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.editReply({
+            content: 'Session expired. Please run /login again.',
+        });
+        return;
+    }
+    const apiKey = interaction.fields.getTextInputValue('apikey');
+    if (!apiKey?.trim()) {
+        await interaction.editReply({
+            content: 'API key is required.',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({
+                content: getClient.message,
+            });
+            return;
+        }
+        // Set the API key
+        await getClient().auth.set({
+            path: { id: context.providerId },
+            body: {
+                type: 'api',
+                key: apiKey.trim(),
+            },
+            query: { directory: context.dir },
+        });
+        // Dispose to refresh provider state so new credentials are recognized
+        await getClient().instance.dispose({ query: { directory: context.dir } });
+        await interaction.editReply({
+            content: `✅ **Successfully authenticated with ${context.providerName}!**\n\nYou can now use models from this provider.`,
+        });
+        // Clean up context
+        pendingLoginContexts.delete(contextHash);
+    }
+    catch (error) {
+        loginLogger.error('API key save error:', error);
+        await interaction.editReply({
+            content: `**Failed to save API key**\n${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/merge-worktree.js

@@ -0,0 +1,165 @@
+// /merge-worktree command - Merge worktree commits into main/default branch.
+// Handles both branch-based worktrees and detached HEAD state.
+// After merge, switches to detached HEAD at main so user can keep working.
+import {} from 'discord.js';
+import { getThreadWorktree } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { execAsync } from '../worktree-utils.js';
+const logger = createLogger(LogPrefix.WORKTREE);
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ ';
+/**
+ * Remove the worktree prefix from a thread title.
+ * Uses Promise.race with timeout since Discord thread title updates can hang.
+ */
+async function removeWorktreePrefixFromTitle(thread) {
+    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+        return;
+    }
+    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    // Race between the edit and a timeout - thread title updates are heavily rate-limited
+    const timeoutMs = 5000;
+    const editPromise = thread.setName(newName).catch((e) => {
+        logger.warn(`Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`);
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            logger.warn(`Thread title update timed out after ${timeoutMs}ms`);
+            resolve();
+        }, timeoutMs);
+    });
+    await Promise.race([editPromise, timeoutPromise]);
+}
+/**
+ * Check if worktree is in detached HEAD state.
+ */
+async function isDetachedHead(worktreeDir) {
+    try {
+        await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`);
+        return false;
+    }
+    catch (error) {
+        logger.debug(`Failed to resolve HEAD for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+        return true;
+    }
+}
+/**
+ * Get current branch name (returns null if detached).
+ */
+async function getCurrentBranch(worktreeDir) {
+    try {
+        const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+        return stdout.trim() || null;
+    }
+    catch (error) {
+        logger.debug(`Failed to get current branch for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}
+export async function handleMergeWorktreeCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const channel = command.channel;
+    // Must be in a thread
+    if (!channel || !channel.isThread()) {
+        await command.editReply('This command can only be used in a thread');
+        return;
+    }
+    const thread = channel;
+    // Get worktree info from database
+    const worktreeInfo = getThreadWorktree(thread.id);
+    if (!worktreeInfo) {
+        await command.editReply('This thread is not associated with a worktree');
+        return;
+    }
+    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+        return;
+    }
+    const mainRepoDir = worktreeInfo.project_directory;
+    const worktreeDir = worktreeInfo.worktree_directory;
+    try {
+        // 1. Check for uncommitted changes
+        const { stdout: status } = await execAsync(`git -C "${worktreeDir}" status --porcelain`);
+        if (status.trim()) {
+            await command.editReply(`❌ Uncommitted changes detected in worktree.\n\nPlease commit your changes first, then retry \`/merge-worktree\`.`);
+            return;
+        }
+        // 2. Get the default branch name
+        logger.log(`Getting default branch for ${mainRepoDir}`);
+        let defaultBranch;
+        try {
+            const { stdout } = await execAsync(`git -C "${mainRepoDir}" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`);
+            defaultBranch = stdout.trim() || 'main';
+        }
+        catch (error) {
+            logger.warn(`Failed to detect default branch for ${mainRepoDir}, falling back to main:`, error instanceof Error ? error.message : String(error));
+            defaultBranch = 'main';
+        }
+        // 3. Determine if we're on a branch or detached HEAD
+        const isDetached = await isDetachedHead(worktreeDir);
+        const currentBranch = await getCurrentBranch(worktreeDir);
+        let branchToMerge;
+        let tempBranch = null;
+        if (isDetached) {
+            // Create a temporary branch from detached HEAD
+            tempBranch = `temp-merge-${Date.now()}`;
+            logger.log(`Detached HEAD detected, creating temp branch: ${tempBranch}`);
+            await execAsync(`git -C "${worktreeDir}" checkout -b ${tempBranch}`);
+            branchToMerge = tempBranch;
+        }
+        else {
+            branchToMerge = currentBranch || worktreeInfo.worktree_name;
+        }
+        logger.log(`Default branch: ${defaultBranch}, branch to merge: ${branchToMerge}`);
+        // 4. Merge default branch INTO worktree (handles diverged branches)
+        logger.log(`Merging ${defaultBranch} into worktree at ${worktreeDir}`);
+        try {
+            await execAsync(`git -C "${worktreeDir}" merge ${defaultBranch} --no-edit`);
+        }
+        catch (e) {
+            // If merge fails (conflicts), abort and report
+            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch((error) => {
+                logger.warn(`Failed to abort merge in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
+            // Clean up temp branch if we created one
+            if (tempBranch) {
+                await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch((error) => {
+                    logger.warn(`Failed to detach HEAD after merge conflict in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
+                await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch((error) => {
+                    logger.warn(`Failed to delete temp branch ${tempBranch} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
+            }
+            throw new Error(`Merge conflict - resolve manually in worktree then retry`);
+        }
+        // 5. Update default branch ref to point to current HEAD
+        // Use update-ref instead of fetch because fetch refuses if branch is checked out
+        logger.log(`Updating ${defaultBranch} to point to current HEAD`);
+        const { stdout: commitHash } = await execAsync(`git -C "${worktreeDir}" rev-parse HEAD`);
+        await execAsync(`git -C "${mainRepoDir}" update-ref refs/heads/${defaultBranch} ${commitHash.trim()}`);
+        // 6. Switch to detached HEAD at default branch (allows main to be checked out elsewhere)
+        logger.log(`Switching to detached HEAD at ${defaultBranch}`);
+        await execAsync(`git -C "${worktreeDir}" checkout --detach ${defaultBranch}`);
+        // 7. Delete the merged branch (temp or original)
+        logger.log(`Deleting merged branch ${branchToMerge}`);
+        await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch((error) => {
+            logger.warn(`Failed to delete merged branch ${branchToMerge} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+        });
+        // Also delete the original worktree branch if different from what we merged
+        if (!isDetached && branchToMerge !== worktreeInfo.worktree_name) {
+            await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch((error) => {
+                logger.warn(`Failed to delete worktree branch ${worktreeInfo.worktree_name} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
+        }
+        // 8. Remove worktree prefix from thread title (fire and forget with timeout)
+        void removeWorktreePrefixFromTitle(thread);
+        const sourceDesc = isDetached ? 'detached commits' : `\`${branchToMerge}\``;
+        await command.editReply(`✅ Merged ${sourceDesc} into \`${defaultBranch}\`\n\nWorktree now at detached HEAD - you can keep working here.`);
+        logger.log(`Successfully merged ${branchToMerge} into ${defaultBranch}`);
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        logger.error(`Merge failed: ${errorMsg}`);
+        await command.editReply(`❌ Merge failed:\n\`\`\`\n${errorMsg}\n\`\`\``);
+    }
+}