kimaki 0.1.5 → 0.2.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord
 import path from 'node:path';
 import fs from 'node:fs';
 import { createLogger } from './logger.js';
+import { spawnSync, execSync } from 'node:child_process';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
@@ -75,6 +76,56 @@ async function ensureKimakiCategory(guild) {
 async function run({ restart, addChannels }) {
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
+    // Step 0: Check if OpenCode CLI is available
+    const opencodeCheck = spawnSync('which', ['opencode'], { shell: true });
+    if (opencodeCheck.status !== 0) {
+        note('OpenCode CLI is required but not found in your PATH.', '⚠️  OpenCode Not Found');
+        const shouldInstall = await confirm({
+            message: 'Would you like to install OpenCode right now?',
+        });
+        if (isCancel(shouldInstall) || !shouldInstall) {
+            cancel('OpenCode CLI is required to run this bot');
+            process.exit(0);
+        }
+        const s = spinner();
+        s.start('Installing OpenCode CLI...');
+        try {
+            execSync('curl -fsSL https://opencode.ai/install | bash', {
+                stdio: 'inherit',
+                shell: '/bin/bash',
+            });
+            s.stop('OpenCode CLI installed successfully!');
+            // The install script adds opencode to PATH via shell configuration
+            // For the current process, we need to check common installation paths
+            const possiblePaths = [
+                `${process.env.HOME}/.local/bin/opencode`,
+                `${process.env.HOME}/.opencode/bin/opencode`,
+                '/usr/local/bin/opencode',
+                '/opt/opencode/bin/opencode',
+            ];
+            const installedPath = possiblePaths.find((p) => {
+                try {
+                    fs.accessSync(p, fs.constants.F_OK);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (!installedPath) {
+                note('OpenCode was installed but may not be available in this session.\n' +
+                    'Please restart your terminal and run this command again.', '⚠️  Restart Required');
+                process.exit(0);
+            }
+            // For subsequent spawn calls in this session, we can use the full path
+            process.env.OPENCODE_PATH = installedPath;
+        }
+        catch (error) {
+            s.stop('Failed to install OpenCode CLI');
+            cliLogger.error('Installation error:', error instanceof Error ? error.message : String(error));
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
     const db = getDatabase();
     let appId;
     let token;
@@ -231,7 +282,7 @@ async function run({ restart, addChannels }) {
     s.start('Fetching OpenCode projects...');
     let projects = [];
     try {
-        const projectsResponse = await getClient().project.list();
+        const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             throw new Error('Failed to fetch projects');
         }
@@ -270,23 +321,23 @@ async function run({ restart, addChannels }) {
             }
             if (guilds.length === 1) {
                 targetGuild = guilds[0];
+                note(`Using server: ${targetGuild.name}`, 'Server Selected');
             }
             else {
-                const guildId = await text({
-                    message: 'Enter the Discord server ID to create channels in:',
-                    placeholder: guilds[0]?.id,
-                    validate(value) {
-                        if (!value)
-                            return 'Server ID is required';
-                        if (!guilds.find((g) => g.id === value))
-                            return 'Invalid server ID';
-                    },
+                const guildSelection = await multiselect({
+                    message: 'Select a Discord server to create channels in:',
+                    options: guilds.map((guild) => ({
+                        value: guild.id,
+                        label: `${guild.name} (${guild.memberCount} members)`,
+                    })),
+                    required: true,
+                    maxItems: 1,
                 });
-                if (isCancel(guildId)) {
+                if (isCancel(guildSelection)) {
                     cancel('Setup cancelled');
                     process.exit(0);
                 }
-                targetGuild = guilds.find((g) => g.id === guildId);
+                targetGuild = guilds.find((g) => g.id === guildSelection[0]);
             }
             s.start('Creating Discord channels...');
             for (const projectId of selectedProjects) {

package/dist/discordBot.js

@@ -27,8 +27,11 @@ const dbLogger = createLogger('DB');
 const opencodeServers = new Map();
 // Map of session ID to current AbortController
 const abortControllers = new Map();
-// Map of guild ID to voice connection and GenAI worker
+// Map of guild ID to voice connection
 const voiceConnections = new Map();
+// Map of channel ID to GenAI worker and session state
+// This allows sessions to persist across voice channel changes
+const genAiSessions = new Map();
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map();
 let db = null;
@@ -79,7 +82,7 @@ async function createUserAudioLogStream(guildId, channelId) {
     }
 }
 // Set up voice handling for a connection (called once per connection)
-async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
+async function setupVoiceHandling({ connection, guildId, channelId, appId, cleanupGenAiSession, }) {
     voiceLogger.log(`Setting up voice handling for guild ${guildId}, channel ${channelId}`);
     // Check if this voice channel has an associated directory
     const channelDirRow = getDatabase()
@@ -99,11 +102,28 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
     }
     // Create user audio stream for debugging
     voiceData.userAudioStream = await createUserAudioLogStream(guildId, channelId);
+    // Check if we already have a GenAI session for this channel
+    const existingSession = genAiSessions.get(channelId);
+    if (existingSession) {
+        voiceLogger.log(`Reusing existing GenAI session for channel ${channelId}`);
+        // Cancel any pending cleanup since user has returned
+        if (existingSession.pendingCleanup) {
+            voiceLogger.log(`Cancelling pending cleanup for channel ${channelId} - user returned`);
+            existingSession.pendingCleanup = false;
+            if (existingSession.cleanupTimer) {
+                clearTimeout(existingSession.cleanupTimer);
+                existingSession.cleanupTimer = undefined;
+            }
+        }
+        // Session already exists, just update the voice handling
+        return;
+    }
     // Get API keys from database
     const apiKeys = getDatabase()
         .prepare('SELECT gemini_api_key FROM bot_api_keys WHERE app_id = ?')
         .get(appId);
-    // Create GenAI worker
+    // Track if sessions are active
+    let hasActiveSessions = false;
     const genAiWorker = await createGenAIWorker({
         directory,
         guildId,
@@ -171,28 +191,75 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
             genAiWorker.interrupt();
             connection.setSpeaking(false);
         },
+        onAllSessionsCompleted() {
+            // All OpenCode sessions have completed
+            hasActiveSessions = false;
+            voiceLogger.log('All OpenCode sessions completed for this GenAI session');
+            // Update the stored session state
+            const session = genAiSessions.get(channelId);
+            if (session) {
+                session.hasActiveSessions = false;
+                // If cleanup is pending (user left channel), schedule cleanup with grace period
+                if (session.pendingCleanup) {
+                    voiceLogger.log(`Scheduling cleanup for channel ${channelId} in 1 minute`);
+                    // Clear any existing timer
+                    if (session.cleanupTimer) {
+                        clearTimeout(session.cleanupTimer);
+                    }
+                    // Schedule cleanup after 1 minute grace period
+                    session.cleanupTimer = setTimeout(() => {
+                        // Double-check that cleanup is still needed
+                        const currentSession = genAiSessions.get(channelId);
+                        if (currentSession?.pendingCleanup &&
+                            !currentSession.hasActiveSessions) {
+                            voiceLogger.log(`Grace period expired, cleaning up GenAI session for channel ${channelId}`);
+                            // Use the main cleanup function - defined later in startDiscordBot
+                            cleanupGenAiSession(channelId);
+                        }
+                    }, 60000); // 1 minute
+                }
+            }
+        },
         onToolCallCompleted(params) {
+            // Note: We now track at the tools.ts level, but still handle completion messages
+            voiceLogger.log(`OpenCode session ${params.sessionId} completed`);
             const text = params.error
                 ? `<systemMessage>\nThe coding agent encountered an error while processing session ${params.sessionId}: ${params.error?.message || String(params.error)}\n</systemMessage>`
                 : `<systemMessage>\nThe coding agent finished working on session ${params.sessionId}\n\nHere's what the assistant wrote:\n${params.markdown}\n</systemMessage>`;
             genAiWorker.sendTextInput(text);
+            // Mark that we have active sessions (will be updated by onAllSessionsCompleted when done)
+            hasActiveSessions = true;
+            const session = genAiSessions.get(channelId);
+            if (session) {
+                session.hasActiveSessions = true;
+            }
         },
         onError(error) {
             voiceLogger.error('GenAI worker error:', error);
         },
     });
-    // Stop any existing GenAI worker before storing new one
-    if (voiceData.genAiWorker) {
-        voiceLogger.log('Stopping existing GenAI worker before creating new one');
-        await voiceData.genAiWorker.stop();
-    }
     // Send initial greeting
     genAiWorker.sendTextInput(`<systemMessage>\nsay "Hello boss, how we doing today?"\n</systemMessage>`);
-    voiceData.genAiWorker = genAiWorker;
+    // Store the GenAI session
+    genAiSessions.set(channelId, {
+        genAiWorker,
+        hasActiveSessions,
+        pendingCleanup: false,
+        cleanupTimer: undefined,
+        guildId,
+        channelId,
+        directory,
+    });
     // Set up voice receiver for user input
     const receiver = connection.receiver;
     // Remove all existing listeners to prevent accumulation
     receiver.speaking.removeAllListeners('start');
+    // Get the GenAI session for this channel
+    const genAiSession = genAiSessions.get(channelId);
+    if (!genAiSession) {
+        voiceLogger.error(`GenAI session was just created but not found for channel ${channelId}`);
+        return;
+    }
     // Counter to track overlapping speaking sessions
     let speakingSessionCount = 0;
     receiver.speaking.on('start', (userId) => {
@@ -239,15 +306,16 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
                 // )
                 return;
             }
-            if (!voiceData.genAiWorker) {
-                voiceLogger.warn(`[VOICE] Received audio frame but no GenAI worker active for guild ${guildId}`);
+            const genAiSession = genAiSessions.get(channelId);
+            if (!genAiSession) {
+                voiceLogger.warn(`[VOICE] Received audio frame but no GenAI session active for channel ${channelId}`);
                 return;
             }
             // voiceLogger.debug('User audio chunk length', frame.length)
             // Write to PCM file if stream exists
             voiceData.userAudioStream?.write(frame);
             // stream incrementally — low latency
-            voiceData.genAiWorker.sendRealtimeInput({
+            genAiSession.genAiWorker.sendRealtimeInput({
                 audio: {
                     mimeType: 'audio/pcm;rate=16000',
                     data: frame.toString('base64'),
@@ -258,7 +326,8 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
             // Only send audioStreamEnd if this is still the current session
             if (currentSessionCount === speakingSessionCount) {
                 voiceLogger.log(`User ${userId} stopped speaking (session ${currentSessionCount})`);
-                voiceData.genAiWorker?.sendRealtimeInput({
+                const genAiSession = genAiSessions.get(channelId);
+                genAiSession?.genAiWorker.sendRealtimeInput({
                     audioStreamEnd: true,
                 });
             }
@@ -281,7 +350,7 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
         });
     });
 }
-export function frameMono16khz() {
+function frameMono16khz() {
     // Hardcoded: 16 kHz, mono, 16-bit PCM, 20 ms -> 320 samples -> 640 bytes
     const FRAME_BYTES = (100 /*ms*/ * 16_000 /*Hz*/ * 1 /*channels*/ * 2) /*bytes per sample*/ /
         1000;
@@ -608,7 +677,8 @@ export async function initializeOpencodeForDirectory(directory) {
     // console.log(
     //   `[OPENCODE] Starting new server on port ${port} for directory: ${directory}`,
     // )
-    const serverProcess = spawn('opencode', ['serve', '--port', port.toString()], {
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
         stdio: 'pipe',
         detached: false,
         cwd: directory,
@@ -648,7 +718,18 @@ export async function initializeOpencodeForDirectory(directory) {
         }
     });
     await waitForServer(port);
-    const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+    // Create a custom fetch that disables Bun's default timeout
+    const customFetch = (input, init) => {
+        return fetch(input, {
+            ...init,
+            // @ts-ignore - Bun-specific option to disable timeout
+            timeout: false,
+        });
+    };
+    const client = createOpencodeClient({
+        baseUrl: `http://localhost:${port}`,
+        fetch: customFetch,
+    });
     opencodeServers.set(directory, {
         process: serverProcess,
         client,
@@ -730,7 +811,7 @@ function formatPart(part) {
                 const icon = part.state.status === 'completed'
                     ? '◼︎'
                     : part.state.status === 'error'
-                        ? '✖️'
+                        ? '⨯'
                         : '';
                 const title = `${icon} ${part.tool} ${toolTitle}`;
                 let text = title;
@@ -1400,11 +1481,147 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await interaction.respond([]);
                     }
                 }
+                else if (interaction.commandName === 'session') {
+                    const focusedOption = interaction.options.getFocused(true);
+                    if (focusedOption.name === 'files') {
+                        const focusedValue = focusedOption.value;
+                        // Split by comma to handle multiple files
+                        const parts = focusedValue.split(',');
+                        const previousFiles = parts
+                            .slice(0, -1)
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        const currentQuery = (parts[parts.length - 1] || '').trim();
+                        // Get the channel's project directory from its topic
+                        let projectDirectory;
+                        if (interaction.channel &&
+                            interaction.channel.type === ChannelType.GuildText) {
+                            const textChannel = resolveTextChannel(interaction.channel);
+                            if (textChannel) {
+                                const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
+                                if (channelAppId && channelAppId !== currentAppId) {
+                                    await interaction.respond([]);
+                                    return;
+                                }
+                                projectDirectory = directory;
+                            }
+                        }
+                        if (!projectDirectory) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        try {
+                            // Get OpenCode client for this directory
+                            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                            // Use find.files to search for files based on current query
+                            const response = await getClient().find.files({
+                                query: {
+                                    query: currentQuery || '',
+                                },
+                            });
+                            // Get file paths from the response
+                            const files = response.data || [];
+                            // Build the prefix with previous files
+                            const prefix = previousFiles.length > 0
+                                ? previousFiles.join(', ') + ', '
+                                : '';
+                            // Map to Discord autocomplete format
+                            const choices = files
+                                .slice(0, 25) // Discord limit
+                                .map((file) => {
+                                const fullValue = prefix + file;
+                                // Get all basenames for display
+                                const allFiles = [...previousFiles, file];
+                                const allBasenames = allFiles.map((f) => f.split('/').pop() || f);
+                                let displayName = allBasenames.join(', ');
+                                // Truncate if too long
+                                if (displayName.length > 100) {
+                                    displayName = '…' + displayName.slice(-97);
+                                }
+                                return {
+                                    name: displayName,
+                                    value: fullValue,
+                                };
+                            });
+                            await interaction.respond(choices);
+                        }
+                        catch (error) {
+                            voiceLogger.error('[AUTOCOMPLETE] Error fetching files:', error);
+                            await interaction.respond([]);
+                        }
+                    }
+                }
             }
             // Handle slash commands
             if (interaction.isChatInputCommand()) {
                 const command = interaction;
-                if (command.commandName === 'resume') {
+                if (command.commandName === 'session') {
+                    await command.deferReply({ ephemeral: false });
+                    const prompt = command.options.getString('prompt', true);
+                    const filesString = command.options.getString('files') || '';
+                    const channel = command.channel;
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in text channels');
+                        return;
+                    }
+                    const textChannel = channel;
+                    // Get project directory from channel topic
+                    let projectDirectory;
+                    let channelAppId;
+                    if (textChannel.topic) {
+                        const extracted = extractTagsArrays({
+                            xml: textChannel.topic,
+                            tags: ['kimaki.directory', 'kimaki.app'],
+                        });
+                        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                        channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                    }
+                    // Check if this channel belongs to current bot instance
+                    if (channelAppId && channelAppId !== currentAppId) {
+                        await command.editReply('This channel is not configured for this bot');
+                        return;
+                    }
+                    if (!projectDirectory) {
+                        await command.editReply('This channel is not configured with a project directory');
+                        return;
+                    }
+                    if (!fs.existsSync(projectDirectory)) {
+                        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+                        return;
+                    }
+                    try {
+                        // Initialize OpenCode client for the directory
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        // Process file mentions - split by comma only
+                        const files = filesString
+                            .split(',')
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        // Build the full prompt with file mentions
+                        let fullPrompt = prompt;
+                        if (files.length > 0) {
+                            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
+                        }
+                        // Send a message first, then create thread from it
+                        const starterMessage = await textChannel.send({
+                            content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+                        });
+                        // Create thread from the message
+                        const thread = await starterMessage.startThread({
+                            name: prompt.slice(0, 100),
+                            autoArchiveDuration: 1440, // 24 hours
+                            reason: 'OpenCode session',
+                        });
+                        await command.editReply(`Created new session in ${thread.toString()}`);
+                        // Start the OpenCode session
+                        await handleOpencodeSession(fullPrompt, thread, projectDirectory);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[SESSION] Error:', error);
+                        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'resume') {
                     await command.deferReply({ ephemeral: false });
                     const sessionId = command.options.getString('session', true);
                     const channel = command.channel;
@@ -1476,11 +1693,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         for (const message of messages) {
                             if (message.info.role === 'user') {
                                 // Render user messages
-                                const userParts = message.parts.filter((p) => p.type === 'text');
+                                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
                                 const userTexts = userParts
                                     .map((p) => {
-                                    if (typeof p.text === 'string') {
-                                        return extractNonXmlContent(p.text);
+                                    if (p.type === 'text') {
+                                        return p.text;
                                     }
                                     return '';
                                 })
@@ -1520,19 +1737,37 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             voiceLogger.error('[INTERACTION] Error handling interaction:', error);
         }
     });
+    // Helper function to clean up GenAI session
+    async function cleanupGenAiSession(channelId) {
+        const genAiSession = genAiSessions.get(channelId);
+        if (!genAiSession)
+            return;
+        try {
+            // Clear any cleanup timer
+            if (genAiSession.cleanupTimer) {
+                clearTimeout(genAiSession.cleanupTimer);
+                genAiSession.cleanupTimer = undefined;
+            }
+            voiceLogger.log(`Stopping GenAI worker for channel ${channelId}...`);
+            await genAiSession.genAiWorker.stop();
+            voiceLogger.log(`GenAI worker stopped for channel ${channelId}`);
+            // Remove from map
+            genAiSessions.delete(channelId);
+            voiceLogger.log(`GenAI session cleanup complete for channel ${channelId}`);
+        }
+        catch (error) {
+            voiceLogger.error(`Error during GenAI session cleanup for channel ${channelId}:`, error);
+            // Still remove from map even if there was an error
+            genAiSessions.delete(channelId);
+        }
+    }
     // Helper function to clean up voice connection and associated resources
-    async function cleanupVoiceConnection(guildId) {
+    async function cleanupVoiceConnection(guildId, channelId) {
         const voiceData = voiceConnections.get(guildId);
         if (!voiceData)
             return;
         voiceLogger.log(`Starting cleanup for guild ${guildId}`);
         try {
-            // Stop GenAI worker if exists (this is async!)
-            if (voiceData.genAiWorker) {
-                voiceLogger.log(`Stopping GenAI worker...`);
-                await voiceData.genAiWorker.stop();
-                voiceLogger.log(`GenAI worker stopped`);
-            }
             // Close user audio stream if exists
             if (voiceData.userAudioStream) {
                 voiceLogger.log(`Closing user audio stream...`);
@@ -1552,7 +1787,33 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             // Remove from map
             voiceConnections.delete(guildId);
-            voiceLogger.log(`Cleanup complete for guild ${guildId}`);
+            voiceLogger.log(`Voice connection cleanup complete for guild ${guildId}`);
+            // Mark the GenAI session for cleanup when all sessions complete
+            if (channelId) {
+                const genAiSession = genAiSessions.get(channelId);
+                if (genAiSession) {
+                    voiceLogger.log(`Marking channel ${channelId} for cleanup when sessions complete`);
+                    genAiSession.pendingCleanup = true;
+                    // If no active sessions, trigger cleanup immediately (with grace period)
+                    if (!genAiSession.hasActiveSessions) {
+                        voiceLogger.log(`No active sessions, scheduling cleanup for channel ${channelId} in 1 minute`);
+                        // Clear any existing timer
+                        if (genAiSession.cleanupTimer) {
+                            clearTimeout(genAiSession.cleanupTimer);
+                        }
+                        // Schedule cleanup after 1 minute grace period
+                        genAiSession.cleanupTimer = setTimeout(() => {
+                            // Double-check that cleanup is still needed
+                            const currentSession = genAiSessions.get(channelId);
+                            if (currentSession?.pendingCleanup &&
+                                !currentSession.hasActiveSessions) {
+                                voiceLogger.log(`Grace period expired, cleaning up GenAI session for channel ${channelId}`);
+                                cleanupGenAiSession(channelId);
+                            }
+                        }, 60000); // 1 minute
+                    }
+                }
+            }
         }
         catch (error) {
             voiceLogger.error(`Error during cleanup for guild ${guildId}:`, error);
@@ -1595,7 +1856,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     if (!hasOtherAdmins) {
                         voiceLogger.log(`No other admins in channel, bot leaving voice channel in guild: ${guild.name}`);
                         // Properly clean up all resources
-                        await cleanupVoiceConnection(guildId);
+                        await cleanupVoiceConnection(guildId, oldState.channelId);
                     }
                     else {
                         voiceLogger.log(`Other admins still in channel, bot staying in voice channel`);
@@ -1631,6 +1892,15 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                     selfDeaf: false,
                                     selfMute: false,
                                 });
+                                // Set up voice handling for the new channel
+                                // This will reuse existing GenAI session if one exists
+                                await setupVoiceHandling({
+                                    connection: voiceData.connection,
+                                    guildId,
+                                    channelId: voiceChannel.id,
+                                    appId: currentAppId,
+                                    cleanupGenAiSession,
+                                });
                             }
                         }
                         else {
@@ -1689,6 +1959,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     guildId: newState.guild.id,
                     channelId: voiceChannel.id,
                     appId: currentAppId,
+                    cleanupGenAiSession,
                 });
                 // Handle connection state changes
                 connection.on(VoiceConnectionStatus.Disconnected, async () => {
@@ -1711,7 +1982,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 connection.on(VoiceConnectionStatus.Destroyed, async () => {
                     voiceLogger.log(`Connection destroyed for guild: ${newState.guild.name}`);
                     // Use the cleanup function to ensure everything is properly closed
-                    await cleanupVoiceConnection(newState.guild.id);
+                    await cleanupVoiceConnection(newState.guild.id, voiceChannel.id);
                 });
                 // Handle errors
                 connection.on('error', (error) => {
@@ -1720,7 +1991,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             catch (error) {
                 voiceLogger.error(`Failed to join voice channel:`, error);
-                await cleanupVoiceConnection(newState.guild.id);
+                await cleanupVoiceConnection(newState.guild.id, voiceChannel.id);
             }
         }
         catch (error) {
@@ -1738,18 +2009,32 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
         ;
         global.shuttingDown = true;
         try {
-            // Clean up all voice connections (this includes GenAI workers and audio streams)
-            const cleanupPromises = [];
-            for (const [guildId] of voiceConnections) {
+            // Clean up all voice connections
+            const voiceCleanupPromises = [];
+            for (const [guildId, voiceData] of voiceConnections) {
                 voiceLogger.log(`[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`);
-                cleanupPromises.push(cleanupVoiceConnection(guildId));
-            }
-            // Wait for all cleanups to complete
-            if (cleanupPromises.length > 0) {
-                voiceLogger.log(`[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`);
-                await Promise.allSettled(cleanupPromises);
+                // Find the channel ID for this connection
+                const channelId = voiceData.connection.joinConfig.channelId || undefined;
+                voiceCleanupPromises.push(cleanupVoiceConnection(guildId, channelId));
+            }
+            // Wait for all voice cleanups to complete
+            if (voiceCleanupPromises.length > 0) {
+                voiceLogger.log(`[SHUTDOWN] Waiting for ${voiceCleanupPromises.length} voice connection(s) to clean up...`);
+                await Promise.allSettled(voiceCleanupPromises);
                 discordLogger.log(`All voice connections cleaned up`);
             }
+            // Clean up all GenAI sessions (force cleanup regardless of active sessions)
+            const genAiCleanupPromises = [];
+            for (const [channelId, session] of genAiSessions) {
+                voiceLogger.log(`[SHUTDOWN] Cleaning up GenAI session for channel ${channelId} (active sessions: ${session.hasActiveSessions})`);
+                genAiCleanupPromises.push(cleanupGenAiSession(channelId));
+            }
+            // Wait for all GenAI cleanups to complete
+            if (genAiCleanupPromises.length > 0) {
+                voiceLogger.log(`[SHUTDOWN] Waiting for ${genAiCleanupPromises.length} GenAI session(s) to clean up...`);
+                await Promise.allSettled(genAiCleanupPromises);
+                discordLogger.log(`All GenAI sessions cleaned up`);
+            }
             // Kill all OpenCode servers
             for (const [dir, server] of opencodeServers) {
                 if (!server.process.killed) {

package/dist/genai-worker-wrapper.js

@@ -20,6 +20,9 @@ export function createGenAIWorker(options) {
                 case 'assistantInterruptSpeaking':
                     options.onAssistantInterruptSpeaking?.();
                     break;
+                case 'allSessionsCompleted':
+                    options.onAllSessionsCompleted?.();
+                    break;
                 case 'toolCallCompleted':
                     options.onToolCallCompleted?.(message);
                     break;