kimaki 0.4.12 → 0.4.14

package/dist/discordBot.js

@@ -22,9 +22,25 @@ import { isAbortError } from './utils.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
-export const OPENCODE_SYSTEM_MESSAGE = `
+function parseSlashCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/')) {
+        return { isCommand: false };
+    }
+    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+        return { isCommand: false };
+    }
+    const command = match[1];
+    const args = match[2]?.trim() || '';
+    return { isCommand: true, command, arguments: args };
+}
+export function getOpencodeSystemMessage({ sessionId }) {
+    return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+Your current OpenCode session ID is: ${sessionId}
+
 After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
 
 bunx critique web
@@ -66,6 +82,7 @@ code blocks for tables and diagrams MUST have Max length of 85 characters. other
 
 you can create diagrams wrapping them in code blocks too.
 `;
+}
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 const opencodeLogger = createLogger('OPENCODE');
@@ -129,7 +146,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, discordClient, }) {
     voiceLogger.log(`Setting up voice handling for guild ${guildId}, channel ${channelId}`);
     // Check if this voice channel has an associated directory
     const channelDirRow = getDatabase()
@@ -227,8 +244,24 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
                 : `<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);
         },
-        onError(error) {
+        async onError(error) {
             voiceLogger.error('GenAI worker error:', error);
+            const textChannelRow = getDatabase()
+                .prepare(`SELECT cd2.channel_id FROM channel_directories cd1
+           JOIN channel_directories cd2 ON cd1.directory = cd2.directory
+           WHERE cd1.channel_id = ? AND cd1.channel_type = 'voice' AND cd2.channel_type = 'text'`)
+                .get(channelId);
+            if (textChannelRow) {
+                try {
+                    const textChannel = await discordClient.channels.fetch(textChannelRow.channel_id);
+                    if (textChannel?.isTextBased() && 'send' in textChannel) {
+                        await textChannel.send(`⚠️ Voice session error: ${error}`);
+                    }
+                }
+                catch (e) {
+                    voiceLogger.error('Failed to send error to text channel:', e);
+                }
+            }
         },
     });
     // Stop any existing GenAI worker before storing new one
@@ -912,24 +945,27 @@ function getToolOutputToDisplay(part) {
     if (part.state.status === 'error') {
         return part.state.error || 'Unknown error';
     }
-    if (part.tool === 'todowrite') {
-        const todos = part.state.input?.todos || [];
-        return todos
-            .map((todo) => {
-            let statusIcon = '▢';
-            if (todo.status === 'in_progress') {
-                statusIcon = '●';
-            }
-            if (todo.status === 'completed' || todo.status === 'cancelled') {
-                statusIcon = '■';
-            }
-            return `\`${statusIcon}\` ${todo.content}`;
-        })
-            .filter(Boolean)
-            .join('\n');
-    }
     return '';
 }
+function formatTodoList(part) {
+    if (part.type !== 'tool' || part.tool !== 'todowrite')
+        return '';
+    const todos = part.state.input?.todos || [];
+    if (todos.length === 0)
+        return '';
+    return todos
+        .map((todo, i) => {
+        const num = `${i + 1}.`;
+        if (todo.status === 'in_progress') {
+            return `${num} **${todo.content}**`;
+        }
+        if (todo.status === 'completed' || todo.status === 'cancelled') {
+            return `${num} ~~${todo.content}~~`;
+        }
+        return `${num} ${todo.content}`;
+    })
+        .join('\n');
+}
 function formatPart(part) {
     if (part.type === 'text') {
         return part.text || '';
@@ -952,14 +988,31 @@ function formatPart(part) {
         return `◼︎ snapshot ${part.snapshot}`;
     }
     if (part.type === 'tool') {
+        if (part.tool === 'todowrite') {
+            return formatTodoList(part);
+        }
         if (part.state.status !== 'completed' && part.state.status !== 'error') {
             return '';
         }
         const summaryText = getToolSummaryText(part);
         const outputToDisplay = getToolOutputToDisplay(part);
-        let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
-        if (toolTitle) {
-            toolTitle = `*${toolTitle}*`;
+        let toolTitle = '';
+        if (part.state.status === 'error') {
+            toolTitle = 'error';
+        }
+        else if (part.tool === 'bash') {
+            const command = part.state.input?.command || '';
+            const isSingleLine = !command.includes('\n');
+            const hasBackticks = command.includes('`');
+            if (isSingleLine && command.length <= 120 && !hasBackticks) {
+                toolTitle = `\`${command}\``;
+            }
+            else {
+                toolTitle = part.state.title ? `*${part.state.title}*` : '';
+            }
+        }
+        else if (part.state.title) {
+            toolTitle = `*${part.state.title}*`;
         }
         const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
         const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
@@ -987,7 +1040,7 @@ export async function createDiscordClient() {
         ],
     });
 }
-async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], }) {
+async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     // Track session start time
     const sessionStartTime = Date.now();
@@ -1081,6 +1134,8 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     let currentParts = [];
     let stopTyping = null;
     let usedModel;
+    let usedProviderID;
+    let inputTokens = 0;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1089,14 +1144,11 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         // Skip if already sent
         if (partIdToMessage.has(part.id)) {
-            voiceLogger.log(`[SEND SKIP] Part ${part.id} already sent as message ${partIdToMessage.get(part.id)?.id}`);
             return;
         }
         try {
-            voiceLogger.log(`[SEND] Sending part ${part.id} (type: ${part.type}) to Discord, content length: ${content.length}`);
             const firstMessage = await sendThreadMessage(thread, content);
             partIdToMessage.set(part.id, firstMessage);
-            voiceLogger.log(`[SEND SUCCESS] Part ${part.id} sent as message ${firstMessage.id}`);
             // Store part-message mapping in database
             getDatabase()
                 .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
@@ -1115,12 +1167,10 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 discordLogger.log(`Not starting typing, already aborted`);
                 return () => { };
             }
-            discordLogger.log(`Starting typing for thread ${thread.id}`);
             // Clear any previous typing interval
             if (typingInterval) {
                 clearInterval(typingInterval);
                 typingInterval = null;
-                discordLogger.log(`Cleared previous typing interval`);
             }
             // Send initial typing
             thread.sendTyping().catch((e) => {
@@ -1148,39 +1198,34 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 if (typingInterval) {
                     clearInterval(typingInterval);
                     typingInterval = null;
-                    discordLogger.log(`Stopped typing for thread ${thread.id}`);
                 }
             };
         }
         try {
             let assistantMessageId;
             for await (const event of events) {
-                sessionLogger.log(`Received: ${event.type}`);
                 if (event.type === 'message.updated') {
                     const msg = event.properties.info;
                     if (msg.sessionID !== session.id) {
-                        voiceLogger.log(`[EVENT IGNORED] Message from different session (expected: ${session.id}, got: ${msg.sessionID})`);
                         continue;
                     }
                     // Track assistant message ID
                     if (msg.role === 'assistant') {
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
-                        voiceLogger.log(`[EVENT] Tracking assistant message ${assistantMessageId}`);
-                    }
-                    else {
-                        sessionLogger.log(`Message role: ${msg.role}`);
+                        usedProviderID = msg.providerID;
+                        if (msg.tokens.input > 0) {
+                            inputTokens = msg.tokens.input;
+                        }
                     }
                 }
                 else if (event.type === 'message.part.updated') {
                     const part = event.properties.part;
                     if (part.sessionID !== session.id) {
-                        voiceLogger.log(`[EVENT IGNORED] Part from different session (expected: ${session.id}, got: ${part.sessionID})`);
                         continue;
                     }
                     // Only process parts from assistant messages
                     if (part.messageID !== assistantMessageId) {
-                        voiceLogger.log(`[EVENT IGNORED] Part from non-assistant message (expected: ${assistantMessageId}, got: ${part.messageID})`);
                         continue;
                     }
                     const existingIndex = currentParts.findIndex((p) => p.id === part.id);
@@ -1190,15 +1235,18 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     else {
                         currentParts.push(part);
                     }
-                    voiceLogger.log(`[PART] Update: id=${part.id}, type=${part.type}, text=${'text' in part && typeof part.text === 'string' ? part.text.slice(0, 50) : ''}`);
                     // Start typing on step-start
                     if (part.type === 'step-start') {
                         stopTyping = startTyping(thread);
                     }
                     // Check if this is a step-finish part
                     if (part.type === 'step-finish') {
+                        // Track tokens from step-finish part
+                        if (part.tokens?.input && part.tokens.input > 0) {
+                            inputTokens = part.tokens.input;
+                            voiceLogger.log(`[STEP-FINISH] Captured tokens: ${inputTokens}`);
+                        }
                         // Send all parts accumulated so far to Discord
-                        voiceLogger.log(`[STEP-FINISH] Sending ${currentParts.length} parts to Discord`);
                         for (const p of currentParts) {
                             // Skip step-start and step-finish parts as they have no visual content
                             if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -1269,12 +1317,6 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         pendingPermissions.delete(thread.id);
                     }
                 }
-                else if (event.type === 'file.edited') {
-                    sessionLogger.log(`File edited event received`);
-                }
-                else {
-                    sessionLogger.log(`Unhandled event type: ${event.type}`);
-                }
             }
         }
         catch (e) {
@@ -1287,31 +1329,20 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         finally {
             // Send any remaining parts that weren't sent
-            voiceLogger.log(`[CLEANUP] Checking ${currentParts.length} parts for unsent messages`);
-            let unsentCount = 0;
             for (const part of currentParts) {
                 if (!partIdToMessage.has(part.id)) {
-                    unsentCount++;
-                    voiceLogger.log(`[CLEANUP] Sending unsent part: id=${part.id}, type=${part.type}`);
                     try {
                         await sendPartMessage(part);
                     }
                     catch (error) {
-                        sessionLogger.log(`Failed to send part ${part.id} during cleanup:`, error);
+                        sessionLogger.error(`Failed to send part ${part.id}:`, error);
                     }
                 }
             }
-            if (unsentCount === 0) {
-                sessionLogger.log(`All parts were already sent`);
-            }
-            else {
-                sessionLogger.log(`Sent ${unsentCount} previously unsent parts`);
-            }
             // Stop typing when session ends
             if (stopTyping) {
                 stopTyping();
                 stopTyping = null;
-                sessionLogger.log(`Stopped typing for session`);
             }
             // Only send duration message if request was not aborted or was aborted with 'finished' reason
             if (!abortController.signal.aborted ||
@@ -1319,8 +1350,23 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`);
-                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}`);
+                let contextInfo = '';
+                if (inputTokens > 0 && usedProviderID && usedModel) {
+                    try {
+                        const providersResponse = await getClient().provider.list({ query: { directory } });
+                        const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                        const model = provider?.models?.[usedModel];
+                        if (model?.limit?.context) {
+                            const percentage = Math.round((inputTokens / model.limit.context) * 100);
+                            contextInfo = ` ⋅ ${percentage}%`;
+                        }
+                    }
+                    catch (e) {
+                        sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                    }
+                }
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`);
             }
             else {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
@@ -1328,22 +1374,36 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     };
     try {
-        voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
-        if (images.length > 0) {
-            sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
-        }
         // Start the event handler
         const eventHandlerPromise = eventHandler();
-        const parts = [{ type: 'text', text: prompt }, ...images];
-        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
-        const response = await getClient().session.prompt({
-            path: { id: session.id },
-            body: {
-                parts,
-                system: OPENCODE_SYSTEM_MESSAGE,
-            },
-            signal: abortController.signal,
-        });
+        let response;
+        if (parsedCommand?.isCommand) {
+            sessionLogger.log(`[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`);
+            response = await getClient().session.command({
+                path: { id: session.id },
+                body: {
+                    command: parsedCommand.command,
+                    arguments: parsedCommand.arguments,
+                },
+                signal: abortController.signal,
+            });
+        }
+        else {
+            voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+            if (images.length > 0) {
+                sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
+            }
+            const parts = [{ type: 'text', text: prompt }, ...images];
+            sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+            response = await getClient().session.prompt({
+                path: { id: session.id },
+                body: {
+                    parts,
+                    system: getOpencodeSystemMessage({ sessionId: session.id }),
+                },
+                signal: abortController.signal,
+            });
+        }
         abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
         // Update reaction to success
@@ -1457,7 +1517,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
     discordClient.on(Events.MessageCreate, async (message) => {
         try {
             if (message.author?.bot) {
-                voiceLogger.log(`[IGNORED] Bot message from ${message.author.tag} in channel ${message.channelId}`);
                 return;
             }
             if (message.partial) {
@@ -1475,10 +1534,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const isOwner = message.member.id === message.guild.ownerId;
                 const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
                 if (!isOwner && !isAdmin) {
-                    voiceLogger.log(`[IGNORED] Non-authoritative user ${message.author.tag} (ID: ${message.author.id}) - not owner or admin`);
                     return;
                 }
-                voiceLogger.log(`[AUTHORIZED] Message from ${message.author.tag} (Owner: ${isOwner}, Admin: ${isAdmin})`);
             }
             const channel = message.channel;
             const isThread = [
@@ -1532,12 +1589,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
                 return;
             }
@@ -1598,12 +1657,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
             }
             else {
@@ -1859,10 +1920,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         await command.editReply(`Created new session in ${thread.toString()}`);
                         // Start the OpenCode session
+                        const parsedCommand = parseSlashCommand(fullPrompt);
                         await handleOpencodeSession({
                             prompt: fullPrompt,
                             thread,
                             projectDirectory,
+                            parsedCommand,
                         });
                     }
                     catch (error) {
@@ -1937,52 +2000,37 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
                         // Send initial message to thread
                         await sendThreadMessage(thread, `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
-                        // Render all existing messages
-                        let messageCount = 0;
+                        // Collect all assistant parts first, then only render the last 30
+                        const allAssistantParts = [];
                         for (const message of messages) {
-                            if (message.info.role === 'user') {
-                                // Render user messages
-                                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
-                                const userTexts = userParts
-                                    .map((p) => {
-                                    if (p.type === 'text') {
-                                        return p.text;
-                                    }
-                                    return '';
-                                })
-                                    .filter((t) => t.trim());
-                                const userText = userTexts.join('\n\n');
-                                if (userText) {
-                                    // Escape backticks in user messages to prevent formatting issues
-                                    const escapedText = escapeDiscordFormatting(userText);
-                                    await sendThreadMessage(thread, `**User:**\n${escapedText}`);
-                                }
-                            }
-                            else if (message.info.role === 'assistant') {
-                                // Render assistant parts
-                                const partsToRender = [];
+                            if (message.info.role === 'assistant') {
                                 for (const part of message.parts) {
                                     const content = formatPart(part);
                                     if (content.trim()) {
-                                        partsToRender.push({ id: part.id, content });
+                                        allAssistantParts.push({ id: part.id, content });
                                     }
                                 }
-                                if (partsToRender.length > 0) {
-                                    const combinedContent = partsToRender
-                                        .map((p) => p.content)
-                                        .join('\n\n');
-                                    const discordMessage = await sendThreadMessage(thread, combinedContent);
-                                    const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
-                                    const transaction = getDatabase().transaction((parts) => {
-                                        for (const part of parts) {
-                                            stmt.run(part.id, discordMessage.id, thread.id);
-                                        }
-                                    });
-                                    transaction(partsToRender);
-                                }
                             }
-                            messageCount++;
                         }
+                        const partsToRender = allAssistantParts.slice(-30);
+                        const skippedCount = allAssistantParts.length - partsToRender.length;
+                        if (skippedCount > 0) {
+                            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+                        }
+                        if (partsToRender.length > 0) {
+                            const combinedContent = partsToRender
+                                .map((p) => p.content)
+                                .join('\n\n');
+                            const discordMessage = await sendThreadMessage(thread, combinedContent);
+                            const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                            const transaction = getDatabase().transaction((parts) => {
+                                for (const part of parts) {
+                                    stmt.run(part.id, discordMessage.id, thread.id);
+                                }
+                            });
+                            transaction(partsToRender);
+                        }
+                        const messageCount = messages.length;
                         await sendThreadMessage(thread, `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
                     }
                     catch (error) {
@@ -2146,6 +2194,68 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                     }
                 }
+                else if (command.commandName === 'abort') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const isThread = [
+                        ChannelType.PublicThread,
+                        ChannelType.PrivateThread,
+                        ChannelType.AnnouncementThread,
+                    ].includes(channel.type);
+                    if (!isThread) {
+                        await command.reply({
+                            content: 'This command can only be used in a thread with an active session',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const textChannel = resolveTextChannel(channel);
+                    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+                    if (!directory) {
+                        await command.reply({
+                            content: 'Could not determine project directory for this channel',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const row = getDatabase()
+                        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                        .get(channel.id);
+                    if (!row?.session_id) {
+                        await command.reply({
+                            content: 'No active session in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const sessionId = row.session_id;
+                    try {
+                        const existingController = abortControllers.get(sessionId);
+                        if (existingController) {
+                            existingController.abort(new Error('User requested abort'));
+                            abortControllers.delete(sessionId);
+                        }
+                        const getClient = await initializeOpencodeForDirectory(directory);
+                        await getClient().session.abort({
+                            path: { id: sessionId },
+                        });
+                        await command.reply(`🛑 Request **aborted**`);
+                        sessionLogger.log(`Session ${sessionId} aborted by user`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ABORT] Error:', error);
+                        await command.reply({
+                            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
             }
         }
         catch (error) {
@@ -2321,6 +2431,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     guildId: newState.guild.id,
                     channelId: voiceChannel.id,
                     appId: currentAppId,
+                    discordClient,
                 });
                 // Handle connection state changes
                 connection.on(VoiceConnectionStatus.Disconnected, async () => {

package/dist/tools.js

@@ -8,7 +8,7 @@ const toolsLogger = createLogger('TOOLS');
 import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory, OPENCODE_SYSTEM_MESSAGE, } from './discordBot.js';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discordBot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -48,7 +48,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     body: {
                         parts: [{ type: 'text', text: message }],
                         model: sessionModel,
-                        system: OPENCODE_SYSTEM_MESSAGE,
+                        system: getOpencodeSystemMessage({ sessionId }),
                     },
                 })
                     .then(async (response) => {
@@ -115,7 +115,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
-                            system: OPENCODE_SYSTEM_MESSAGE,
+                            system: getOpencodeSystemMessage({ sessionId: session.data.id }),
                         },
                     })
                         .then(async (response) => {

package/package.json

@@ -2,17 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.12",
-  "scripts": {
-    "dev": "tsx --env-file .env src/cli.ts",
-    "prepublishOnly": "pnpm tsc",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
-  },
+  "version": "0.4.14",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -54,5 +44,14 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.0.17"
+  },
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}