kimaki 0.4.61 → 0.4.63

package/dist/ai-tool-to-genai.js

@@ -1,5 +1,5 @@
-// AI SDK to Google GenAI tool converter.
-// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// Tool definition to Google GenAI tool converter.
+// Transforms Kimaki's minimal Tool definitions into Google GenAI CallableTool format
 // for use with Gemini's function calling in the voice assistant.
 import { Type } from '@google/genai';
 import { z, toJSONSchema } from 'zod';
@@ -8,93 +8,112 @@ import { z, toJSONSchema } from 'zod';
  * Based on the actual implementation used by the GenAI package:
  * https://github.com/googleapis/js-genai/blob/027f09db662ce6b30f737b10b4d2efcb4282a9b6/src/_transformers.ts#L294
  */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
 function jsonSchemaToGenAISchema(jsonSchema) {
     const schema = {};
-    // Map JSON Schema type to GenAI Type
-    if (jsonSchema.type) {
-        switch (jsonSchema.type) {
+    if (typeof jsonSchema === 'boolean') {
+        return schema;
+    }
+    const jsonSchemaType = (() => {
+        if (!jsonSchema.type) {
+            return undefined;
+        }
+        if (typeof jsonSchema.type === 'string') {
+            return jsonSchema.type;
+        }
+        if (Array.isArray(jsonSchema.type)) {
+            return jsonSchema.type.find((t) => t !== 'null') || jsonSchema.type[0];
+        }
+        return undefined;
+    })();
+    if (Array.isArray(jsonSchema.type) && jsonSchema.type.includes('null')) {
+        schema.nullable = true;
+    }
+    if (jsonSchemaType) {
+        switch (jsonSchemaType) {
             case 'string':
                 schema.type = Type.STRING;
                 break;
             case 'number':
                 schema.type = Type.NUMBER;
-                schema.format = jsonSchema.format || 'float';
+                schema.format = typeof jsonSchema.format === 'string' ? jsonSchema.format : 'float';
                 break;
             case 'integer':
                 schema.type = Type.INTEGER;
-                schema.format = jsonSchema.format || 'int32';
+                schema.format = typeof jsonSchema.format === 'string' ? jsonSchema.format : 'int32';
                 break;
             case 'boolean':
                 schema.type = Type.BOOLEAN;
                 break;
-            case 'array':
+            case 'array': {
                 schema.type = Type.ARRAY;
-                if (jsonSchema.items) {
-                    schema.items = jsonSchemaToGenAISchema(jsonSchema.items);
+                const itemsSchema = (() => {
+                    if (!jsonSchema.items) {
+                        return undefined;
+                    }
+                    if (Array.isArray(jsonSchema.items)) {
+                        return jsonSchema.items[0];
+                    }
+                    return jsonSchema.items;
+                })();
+                if (itemsSchema) {
+                    schema.items = jsonSchemaToGenAISchema(itemsSchema);
                 }
-                if (jsonSchema.minItems !== undefined) {
-                    schema.minItems = jsonSchema.minItems;
+                if (typeof jsonSchema.minItems === 'number') {
+                    schema.minItems = String(jsonSchema.minItems);
                 }
-                if (jsonSchema.maxItems !== undefined) {
-                    schema.maxItems = jsonSchema.maxItems;
+                if (typeof jsonSchema.maxItems === 'number') {
+                    schema.maxItems = String(jsonSchema.maxItems);
                 }
                 break;
+            }
             case 'object':
                 schema.type = Type.OBJECT;
                 if (jsonSchema.properties) {
-                    schema.properties = {};
-                    for (const [key, value] of Object.entries(jsonSchema.properties)) {
-                        schema.properties[key] = jsonSchemaToGenAISchema(value);
-                    }
+                    schema.properties = Object.fromEntries(Object.entries(jsonSchema.properties).map(([key, value]) => [
+                        key,
+                        jsonSchemaToGenAISchema(value),
+                    ]));
                 }
-                if (jsonSchema.required) {
+                if (Array.isArray(jsonSchema.required)) {
                     schema.required = jsonSchema.required;
                 }
-                // Note: GenAI Schema doesn't have additionalProperties field
-                // We skip it for now
                 break;
-            default:
-                // For unknown types, keep as-is
-                schema.type = jsonSchema.type;
         }
     }
-    // Copy over common properties
-    if (jsonSchema.description) {
+    if (typeof jsonSchema.description === 'string') {
         schema.description = jsonSchema.description;
     }
-    if (jsonSchema.enum) {
-        schema.enum = jsonSchema.enum.map(String);
+    if (Array.isArray(jsonSchema.enum)) {
+        schema.enum = jsonSchema.enum.map((x) => String(x));
     }
-    if (jsonSchema.default !== undefined) {
+    if ('default' in jsonSchema) {
         schema.default = jsonSchema.default;
     }
-    if (jsonSchema.example !== undefined) {
-        schema.example = jsonSchema.example;
-    }
-    if (jsonSchema.nullable) {
-        schema.nullable = true;
+    if (Array.isArray(jsonSchema.examples) && jsonSchema.examples.length > 0) {
+        schema.example = jsonSchema.examples[0];
     }
-    // Handle anyOf/oneOf as anyOf in GenAI
-    if (jsonSchema.anyOf) {
+    if (Array.isArray(jsonSchema.anyOf)) {
         schema.anyOf = jsonSchema.anyOf.map((s) => jsonSchemaToGenAISchema(s));
     }
-    else if (jsonSchema.oneOf) {
+    else if (Array.isArray(jsonSchema.oneOf)) {
         schema.anyOf = jsonSchema.oneOf.map((s) => jsonSchemaToGenAISchema(s));
     }
-    // Handle number/string specific properties
-    if (jsonSchema.minimum !== undefined) {
+    if (typeof jsonSchema.minimum === 'number') {
         schema.minimum = jsonSchema.minimum;
     }
-    if (jsonSchema.maximum !== undefined) {
+    if (typeof jsonSchema.maximum === 'number') {
         schema.maximum = jsonSchema.maximum;
     }
-    if (jsonSchema.minLength !== undefined) {
-        schema.minLength = jsonSchema.minLength;
+    if (typeof jsonSchema.minLength === 'number') {
+        schema.minLength = String(jsonSchema.minLength);
     }
-    if (jsonSchema.maxLength !== undefined) {
-        schema.maxLength = jsonSchema.maxLength;
+    if (typeof jsonSchema.maxLength === 'number') {
+        schema.maxLength = String(jsonSchema.maxLength);
     }
-    if (jsonSchema.pattern) {
+    if (typeof jsonSchema.pattern === 'string') {
         schema.pattern = jsonSchema.pattern;
     }
     return schema;
@@ -156,12 +175,13 @@ export function aiToolToCallableTool(tool, name) {
                 // Execute the tool if it has an execute function
                 if (tool.execute) {
                     try {
-                        const result = await tool.execute(functionCall.args || {}, {
+                        const args = isRecord(functionCall.args) ? functionCall.args : {};
+                        const result = await tool.execute(args, {
                             toolCallId: functionCall.id || '',
                             messages: [],
                         });
                         // Convert the result to a Part
-                        parts.push({
+                        const part = {
                             functionResponse: {
                                 id: functionCall.id,
                                 name: functionCall.name || toolName,
@@ -169,11 +189,12 @@ export function aiToolToCallableTool(tool, name) {
                                     output: result,
                                 },
                             },
-                        });
+                        };
+                        parts.push(part);
                     }
                     catch (error) {
                         // Handle errors
-                        parts.push({
+                        const part = {
                             functionResponse: {
                                 id: functionCall.id,
                                 name: functionCall.name || toolName,
@@ -181,7 +202,8 @@ export function aiToolToCallableTool(tool, name) {
                                     error: error instanceof Error ? error.message : String(error),
                                 },
                             },
-                        });
+                        };
+                        parts.push(part);
                     }
                 }
             }
@@ -189,9 +211,6 @@ export function aiToolToCallableTool(tool, name) {
         },
     };
 }
-/**
- * Helper to extract schema from AI SDK tool
- */
 export function extractSchemaFromTool(tool) {
     const inputSchema = tool.inputSchema;
     if (!inputSchema) {

package/dist/ai-tool-to-genai.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { tool } from 'ai';
+import { tool } from './ai-tool.js';
 import { z } from 'zod';
 import { Type } from '@google/genai';
 import { aiToolToGenAIFunction, aiToolToCallableTool, extractSchemaFromTool, } from './ai-tool-to-genai.js';

package/dist/ai-tool.js

@@ -0,0 +1,6 @@
+// Minimal tool definition helper used by Kimaki.
+// This replaces the Vercel AI SDK `tool()` helper so Kimaki can define typed
+// tools (Zod input schema + execute) without depending on the full `ai` package.
+export function tool(definition) {
+    return definition;
+}

package/dist/cli.js

@@ -15,7 +15,7 @@ import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuild
 import path from 'node:path';
 import fs from 'node:fs';
 import * as errore from 'errore';
-import { createLogger, LogPrefix } from './logger.js';
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from './discord-utils.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
@@ -1147,7 +1147,7 @@ cli
         });
     }
     catch (error) {
-        cliLogger.error('Unhandled error:', error instanceof Error ? error.message : String(error));
+        cliLogger.error('Unhandled error:', formatErrorWithStack(error));
         process.exit(EXIT_NO_RESTART);
     }
 });

package/dist/commands/context-usage.js

@@ -130,7 +130,9 @@ export async function handleContextUsageCommand({ command }) {
         if (modelID) {
             lines.push(`**Model:** ${modelID}`);
         }
-        lines.push(`**Session cost:** ${formattedCost}`);
+        if (totalCost > 0) {
+            lines.push(`**Session cost:** ${formattedCost}`);
+        }
         await command.editReply({ content: lines.join('\n') });
         logger.log(`Context usage shown for session ${sessionId}: ${totalTokens} tokens`);
     }

package/dist/commands/model.js

@@ -377,62 +377,40 @@ export async function handleModelSelectMenu(interaction) {
     // Build full model ID: provider_id/model_id
     const fullModelId = `${context.providerId}/${selectedModelId}`;
     try {
-        // Store in appropriate table based on context
-        if (context.isThread && context.sessionId) {
-            // Store for session
-            await setSessionModel(context.sessionId, fullModelId);
-            modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`);
-            // Check if there's a running request and abort+retry with new model
-            let retried = false;
-            if (context.thread) {
-                retried = await abortAndRetrySession({
-                    sessionId: context.sessionId,
-                    thread: context.thread,
-                    projectDirectory: context.dir,
-                    appId: context.appId,
-                });
-            }
-            if (retried) {
-                await interaction.editReply({
-                    content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\n_Retrying current request with new model..._`,
-                    components: [],
-                });
-            }
-            else {
-                await interaction.editReply({
-                    content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\``,
-                    components: [],
-                });
-            }
-            // Clean up the context from memory
-            pendingModelContexts.delete(contextHash);
-        }
-        else {
-            // Channel context - show scope selection menu
-            context.selectedModelId = fullModelId;
-            pendingModelContexts.set(contextHash, context);
-            const scopeOptions = [
-                {
-                    label: 'This channel only',
-                    value: 'channel',
-                    description: 'Override for this channel only',
-                },
-                {
-                    label: 'Global default',
-                    value: 'global',
-                    description: 'Set for this channel and as default for all others',
-                },
-            ];
-            const selectMenu = new StringSelectMenuBuilder()
-                .setCustomId(`model_scope:${contextHash}`)
-                .setPlaceholder('Apply to...')
-                .addOptions(scopeOptions);
-            const actionRow = new ActionRowBuilder().addComponents(selectMenu);
-            await interaction.editReply({
-                content: `**Set Model Preference**\nModel: **${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\nApply to:`,
-                components: [actionRow],
-            });
-        }
+        // Always show scope selection menu
+        context.selectedModelId = fullModelId;
+        pendingModelContexts.set(contextHash, context);
+        const scopeOptions = [
+            // Show "this session" option when in a thread with an active session
+            ...(context.isThread && context.sessionId
+                ? [
+                    {
+                        label: 'This session only',
+                        value: 'session',
+                        description: 'Override for this session only',
+                    },
+                ]
+                : []),
+            {
+                label: 'This channel only',
+                value: 'channel',
+                description: 'Override for this channel only',
+            },
+            {
+                label: 'Global default',
+                value: 'global',
+                description: 'Set for this channel and as default for all others',
+            },
+        ];
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_scope:${contextHash}`)
+            .setPlaceholder('Apply to...')
+            .addOptions(scopeOptions);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Model Preference**\nModel: **${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\nApply to:`,
+            components: [actionRow],
+        });
     }
     catch (error) {
         modelLogger.error('Error saving model preference:', error);
@@ -473,15 +451,41 @@ export async function handleModelScopeSelectMenu(interaction) {
     const modelId = context.selectedModelId;
     const modelDisplay = modelId.split('/')[1] || modelId;
     try {
-        if (selectedScope === 'global') {
+        if (selectedScope === 'session') {
+            if (!context.sessionId) {
+                pendingModelContexts.delete(contextHash);
+                await interaction.editReply({
+                    content: 'No active session in this thread. Please run /model in a thread with a session.',
+                    components: [],
+                });
+                return;
+            }
+            await setSessionModel(context.sessionId, modelId);
+            modelLogger.log(`Set model ${modelId} for session ${context.sessionId}`);
+            let retried = false;
+            if (context.thread) {
+                retried = await abortAndRetrySession({
+                    sessionId: context.sessionId,
+                    thread: context.thread,
+                    projectDirectory: context.dir,
+                    appId: context.appId,
+                });
+            }
+            const retryNote = retried ? '\n_Retrying current request with new model..._' : '';
+            await interaction.editReply({
+                content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**\n\`${modelId}\`${retryNote}`,
+                components: [],
+            });
+        }
+        else if (selectedScope === 'global') {
             if (!context.appId) {
+                pendingModelContexts.delete(contextHash);
                 await interaction.editReply({
                     content: 'Cannot set global model: channel is not linked to a bot',
                     components: [],
                 });
                 return;
             }
-            // Set both global default and current channel
             await setGlobalModel(context.appId, modelId);
             await setChannelModel(context.channelId, modelId);
             modelLogger.log(`Set global model ${modelId} for app ${context.appId} and channel ${context.channelId}`);

package/dist/commands/permissions.js

@@ -93,10 +93,7 @@ export async function handlePermissionButton(interaction) {
     const response = actionPart.replace('permission_', '');
     const context = pendingPermissionContexts.get(contextHash);
     if (!context) {
-        await interaction.reply({
-            content: 'This permission request has expired or was already handled.',
-            ephemeral: true,
-        });
+        await interaction.update({ components: [] });
         return;
     }
     await interaction.deferUpdate();

package/dist/commands/queue.js

@@ -178,7 +178,7 @@ export async function handleQueueCommandCommand({ command, appId }) {
         return;
     }
     const commandPayload = { name: commandName, arguments: args };
-    const displayText = `/${commandName}${args ? ` ${args.slice(0, 100)}` : ''}`;
+    const displayText = `/${commandName}`;
     // Check if there's an active request running
     const existingController = abortControllers.get(sessionId);
     const hasActiveRequest = Boolean(existingController && !existingController.signal.aborted);

package/dist/commands/user-command.js

@@ -2,7 +2,7 @@
 // Handles slash commands that map to user-configured commands in opencode.json.
 import { ChannelType } from 'discord.js';
 import { handleOpencodeSession } from '../session-handler.js';
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { sendThreadMessage, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getChannelDirectory, getThreadSession } from '../database.js';
 import fs from 'node:fs';
@@ -12,7 +12,7 @@ export const handleUserCommand = async ({ command, appId }) => {
     // Strip the -cmd suffix to get the actual OpenCode command name
     const commandName = discordCommandName.replace(/-cmd$/, '');
     const args = command.options.getString('arguments') || '';
-    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) with args: ${args}`);
+    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) argsLength=${args.length}`);
     const channel = command.channel;
     userCommandLogger.log(`Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`);
     const isThread = channel &&
@@ -95,10 +95,10 @@ export const handleUserCommand = async ({ command, appId }) => {
         else if (textChannel) {
             // Running in text channel - create a new thread
             const starterMessage = await textChannel.send({
-                content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+                content: `**/${commandName}**`,
                 flags: SILENT_MESSAGE_FLAGS,
             });
-            const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`;
+            const threadName = `/${commandName}`;
             const newThread = await starterMessage.startThread({
                 name: threadName.slice(0, 100),
                 autoArchiveDuration: 1440,
@@ -106,6 +106,10 @@ export const handleUserCommand = async ({ command, appId }) => {
             });
             // Add user to thread so it appears in their sidebar
             await newThread.members.add(command.user.id);
+            if (args) {
+                const argsPreview = args.length > 1800 ? `${args.slice(0, 1800)}\n... truncated` : args;
+                await sendThreadMessage(newThread, `Args: ${argsPreview}`);
+            }
             await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
             await handleOpencodeSession({
                 prompt: '', // Not used when command is set

package/dist/db.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { PrismaLibSql } from '@prisma/adapter-libsql';
 import { PrismaClient, Prisma } from './generated/client.js';
 import { getDataDir } from './config.js';
-import { createLogger, LogPrefix } from './logger.js';
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -38,10 +38,20 @@ async function initializePrisma() {
     dbLogger.log(`Opening database at: ${dbPath}`);
     const adapter = new PrismaLibSql({ url: `file:${dbPath}` });
     const prisma = new PrismaClient({ adapter });
-    // Always run migrations - schema.sql uses IF NOT EXISTS so it's idempotent
-    dbLogger.log(exists ? 'Existing database, running migrations...' : 'New database, running schema setup...');
-    await migrateSchema(prisma);
-    dbLogger.log('Schema migration complete');
+    try {
+        // WAL mode allows concurrent reads while writing instead of blocking.
+        // busy_timeout makes SQLite retry for 5s instead of immediately failing with SQLITE_BUSY.
+        await prisma.$executeRawUnsafe('PRAGMA journal_mode = WAL');
+        await prisma.$executeRawUnsafe('PRAGMA busy_timeout = 5000');
+        // Always run migrations - schema.sql uses IF NOT EXISTS so it's idempotent
+        dbLogger.log(exists ? 'Existing database, running migrations...' : 'New database, running schema setup...');
+        await migrateSchema(prisma);
+        dbLogger.log('Schema migration complete');
+    }
+    catch (error) {
+        dbLogger.error('Prisma init failed:', formatErrorWithStack(error));
+        throw error;
+    }
     prismaInstance = prisma;
     return prisma;
 }

package/dist/discord-bot.js

@@ -24,7 +24,7 @@ export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels,
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import * as errore from 'errore';
-import { createLogger, LogPrefix } from './logger.js';
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { writeHeapSnapshot, startHeapMonitor } from './heap-monitor.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
@@ -700,6 +700,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.log('Ignoring unhandled rejection during shutdown:', reason);
             return;
         }
-        discordLogger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        discordLogger.error('Unhandled rejection:', formatErrorWithStack(reason), 'at promise:', promise);
     });
 }

package/dist/genai-worker.js

@@ -10,7 +10,7 @@ import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
 import { mkdir } from 'node:fs/promises';
-import { createLogger, LogPrefix } from './logger.js';
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
 }
@@ -33,8 +33,9 @@ process.on('uncaughtException', (error) => {
     process.exit(1);
 });
 process.on('unhandledRejection', (reason, promise) => {
-    workerLogger.error('Unhandled rejection in worker:', reason, 'at promise:', promise);
-    sendError(`Worker unhandled rejection: ${reason}`);
+    const formattedReason = formatErrorWithStack(reason);
+    workerLogger.error('Unhandled rejection in worker:', formattedReason, 'at promise:', promise);
+    sendError(`Worker unhandled rejection: ${formattedReason}`);
 });
 // Audio configuration
 const AUDIO_CONFIG = {

package/dist/logger.js

@@ -66,6 +66,16 @@ function formatArg(arg) {
     }
     return util.inspect(arg, { colors: true, depth: 4 });
 }
+export function formatErrorWithStack(error) {
+    if (error instanceof Error) {
+        return error.stack ?? `${error.name}: ${error.message}`;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    // Keep this stable and safe for unknown values (handles circular structures).
+    return util.inspect(error, { colors: false, depth: 4 });
+}
 function writeToFile(level, prefix, args) {
     if (!isDev) {
         return;

package/dist/session-handler.js

@@ -17,6 +17,7 @@ import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
 import { showPermissionButtons, cleanupPermissionContext, addPermissionRequestToContext, arePatternsCoveredBy, } from './commands/permissions.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
+import { execAsync } from './worktree-utils.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
@@ -494,7 +495,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         await Promise.race([
             previousHandler,
             new Promise((resolve) => {
-                setTimeout(resolve, 1500);
+                setTimeout(resolve, 2500);
             }),
         ]);
     }
@@ -1028,7 +1029,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
             sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
             const displayText = nextMessage.command
-                ? `/${nextMessage.command.name}${nextMessage.command.arguments ? ` ${nextMessage.command.arguments.slice(0, 120)}` : ''}`
+                ? `/${nextMessage.command.name}`
                 : `${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`;
             await sendThreadMessage(thread, `» **${nextMessage.username}:** ${displayText}`);
             setImmediate(() => {
@@ -1165,6 +1166,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
                 const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : '';
                 let contextInfo = '';
+                const folderName = path.basename(sdkDirectory);
+                const branchResult = await errore.tryAsync(() => {
+                    return execAsync('git symbolic-ref --short HEAD', { cwd: sdkDirectory });
+                });
+                const branchName = branchResult instanceof Error ? '' : branchResult.stdout.trim();
                 const contextResult = await errore.tryAsync(async () => {
                     // Fetch final token count from API since message.updated events can arrive
                     // after session.idle due to race conditions in event ordering
@@ -1198,7 +1204,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 if (contextResult instanceof Error) {
                     sessionLogger.error('Failed to fetch provider info for context percentage:', contextResult);
                 }
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS });
+                const projectInfo = branchName ? `${folderName} ⋅ ${branchName} ⋅ ` : `${folderName} ⋅ `;
+                await sendThreadMessage(thread, `*${projectInfo}${sessionDuration}${contextInfo}${attachCommand}${modelInfo}${agentInfo}*`, { flags: NOTIFY_MESSAGE_FLAGS });
                 sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
                 // Process queued messages after completion
                 const queue = messageQueue.get(thread.id);
@@ -1210,7 +1217,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     sessionLogger.log(`[QUEUE] Processing queued message from ${nextMessage.username}`);
                     // Show that queued message is being sent
                     const displayText = nextMessage.command
-                        ? `/${nextMessage.command.name}${nextMessage.command.arguments ? ` ${nextMessage.command.arguments.slice(0, 120)}` : ''}`
+                        ? `/${nextMessage.command.name}`
                         : `${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`;
                     await sendThreadMessage(thread, `» **${nextMessage.username}:** ${displayText}`);
                     // Send the queued message as a new prompt (recursive call)

package/dist/tools.js

@@ -1,7 +1,7 @@
 // Voice assistant tool definitions for the GenAI worker.
 // Provides tools for managing OpenCode sessions (create, submit, abort),
 // listing chats, searching files, and reading session messages.
-import { tool } from 'ai';
+import { tool } from './ai-tool.js';
 import { z } from 'zod';
 import { spawn } from 'node:child_process';
 import net from 'node:net';