kimaki 0.4.62 → 0.4.64

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,11 +15,11 @@ 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';
-import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity, setDefaultMentionMode, getProjectsDir } from './config.js';
+import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity, setDefaultMentionMode, setCritiqueEnabled, getProjectsDir } from './config.js';
 import { sanitizeAgentName } from './commands/agent.js';
 import { showFileUploadButton, } from './commands/file-upload.js';
 import { execAsync } from './worktree-utils.js';
@@ -1105,6 +1105,7 @@ cli
     .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
     .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
     .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
+    .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .action(async (options) => {
     try {
@@ -1126,6 +1127,10 @@ cli
             setDefaultMentionMode(true);
             cliLogger.log('Default mention mode: enabled (bot only responds when @mentioned)');
         }
+        if (options.noCritique) {
+            setCritiqueEnabled(false);
+            cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
+        }
         if (options.installUrl) {
             await initDatabase();
             const existingBot = await getBotToken();
@@ -1147,7 +1152,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);
     }
 });
@@ -1992,15 +1997,48 @@ cli
             cliLogger.error('Failed to connect to OpenCode:', getClient.message);
             process.exit(EXIT_NO_RESTART);
         }
+        // Try current project first (fast path)
         const markdown = new ShareMarkdown(getClient());
         const result = await markdown.generate({ sessionID: sessionId });
-        if (result instanceof Error) {
-            cliLogger.error(result.message);
-            process.exit(EXIT_NO_RESTART);
+        if (!(result instanceof Error)) {
+            process.stdout.write(result);
+            process.exit(0);
         }
-        // Print to stdout so it can be piped: kimaki session read <id> > ./tmp/session.md
-        process.stdout.write(result);
-        process.exit(0);
+        // Session not found in current project, search across all projects.
+        // project.list() returns all known projects globally from any OpenCode server,
+        // but session.list/get are scoped to the server's own project. So we try each.
+        cliLogger.log('Session not in current project, searching all projects...');
+        const projectsResponse = await getClient().project.list({});
+        const projects = projectsResponse.data || [];
+        const otherProjects = projects
+            .filter((p) => path.resolve(p.worktree) !== projectDirectory)
+            .filter((p) => {
+            try {
+                fs.accessSync(p.worktree, fs.constants.R_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })
+            // Sort by most recently created first to find sessions faster
+            .sort((a, b) => b.time.created - a.time.created);
+        for (const project of otherProjects) {
+            const dir = project.worktree;
+            cliLogger.log(`Trying project: ${dir}`);
+            const otherClient = await initializeOpencodeForDirectory(dir);
+            if (otherClient instanceof Error) {
+                continue;
+            }
+            const otherMarkdown = new ShareMarkdown(otherClient());
+            const otherResult = await otherMarkdown.generate({ sessionID: sessionId });
+            if (!(otherResult instanceof Error)) {
+                process.stdout.write(otherResult);
+                process.exit(0);
+            }
+        }
+        cliLogger.error(`Session ${sessionId} not found in any project`);
+        process.exit(EXIT_NO_RESTART);
     }
     catch (error) {
         cliLogger.error('Error:', error instanceof Error ? error.message : String(error));

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/restart-opencode-server.js

@@ -1,9 +1,13 @@
 // /restart-opencode-server command - Restart the opencode server for the current channel.
 // Used for resolving opencode state issues, internal bugs, refreshing auth state, plugins, etc.
+// Aborts all in-progress sessions in this channel before restarting to avoid orphaned requests.
 import { ChannelType } from 'discord.js';
-import { restartOpencodeServer } from '../opencode.js';
+import { initializeOpencodeForDirectory, restartOpencodeServer } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { getAllThreadSessionIds, getThreadIdBySessionId } from '../database.js';
+import { abortControllers } from '../session-handler.js';
+import * as errore from 'errore';
 const logger = createLogger(LogPrefix.OPENCODE);
 export async function handleRestartOpencodeServerCommand({ command, appId }) {
     const channel = command.channel;
@@ -49,6 +53,49 @@ export async function handleRestartOpencodeServerCommand({ command, appId }) {
     }
     // Defer reply since restart may take a moment
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    // Abort all in-progress sessions in this channel before restarting.
+    // Find sessions with active abort controllers, check if their thread belongs
+    // to this channel (thread parentId matches, or command was run in the thread itself).
+    const parentChannelId = isThread ? channel.parentId : channel.id;
+    const activeSessionIds = [...abortControllers.keys()];
+    let abortedCount = 0;
+    if (activeSessionIds.length > 0) {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const client = !(getClient instanceof Error) ? getClient : null;
+        for (const sessionId of activeSessionIds) {
+            const threadId = await getThreadIdBySessionId(sessionId);
+            if (!threadId) {
+                continue;
+            }
+            // Check if thread belongs to this channel: either the thread IS this channel,
+            // or the thread's parent matches the parent channel
+            const threadChannel = await errore.tryAsync(() => {
+                return command.client.channels.fetch(threadId);
+            });
+            if (threadChannel instanceof Error || !threadChannel) {
+                continue;
+            }
+            const threadParentId = 'parentId' in threadChannel ? threadChannel.parentId : null;
+            if (threadId !== channel.id && threadParentId !== parentChannelId) {
+                continue;
+            }
+            const controller = abortControllers.get(sessionId);
+            if (controller) {
+                logger.log(`[RESTART] Aborting session ${sessionId} in thread ${threadId}`);
+                controller.abort(new Error('Server restart requested'));
+                abortControllers.delete(sessionId);
+                abortedCount++;
+            }
+            if (client) {
+                await errore.tryAsync(() => {
+                    return client().session.abort({ path: { id: sessionId } });
+                });
+            }
+        }
+    }
+    if (abortedCount > 0) {
+        logger.log(`[RESTART] Aborted ${abortedCount} active session(s) before restart`);
+    }
     logger.log(`[RESTART] Restarting opencode server for directory: ${projectDirectory}`);
     const result = await restartOpencodeServer(projectDirectory);
     if (result instanceof Error) {
@@ -58,8 +105,9 @@ export async function handleRestartOpencodeServerCommand({ command, appId }) {
         });
         return;
     }
+    const abortMsg = abortedCount > 0 ? ` (aborted ${abortedCount} active session${abortedCount > 1 ? 's' : ''})` : '';
     await command.editReply({
-        content: `🔄 Opencode server **restarted** successfully`,
+        content: `Opencode server **restarted** successfully${abortMsg}`,
     });
     logger.log(`[RESTART] Opencode server restarted for directory: ${projectDirectory}`);
 }

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/config.js

@@ -51,6 +51,15 @@ export function getDefaultMentionMode() {
 export function setDefaultMentionMode(enabled) {
     defaultMentionMode = enabled;
 }
+// Whether critique (diff upload to critique.work) is enabled in system prompts.
+// Enabled by default, disabled via --no-critique CLI flag.
+let critiqueEnabled = true;
+export function getCritiqueEnabled() {
+    return critiqueEnabled;
+}
+export function setCritiqueEnabled(enabled) {
+    critiqueEnabled = enabled;
+}
 export const registeredUserCommands = [];
 const DEFAULT_LOCK_PORT = 29988;
 /**

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,14 +38,20 @@ async function initializePrisma() {
     dbLogger.log(`Opening database at: ${dbPath}`);
     const adapter = new PrismaLibSql({ url: `file:${dbPath}` });
     const prisma = new PrismaClient({ adapter });
-    // 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');
+    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

@@ -381,13 +381,19 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const threadPermissions = pendingPermissions.get(thread.id);
     if (threadPermissions && threadPermissions.size > 0) {
         const clientV2 = getOpencodeClientV2(directory);
-        let rejectedCount = 0;
         for (const [permId, pendingPerm] of threadPermissions) {
             sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`);
+            // Remove the permission buttons from the Discord message
+            const removeButtonsResult = await errore.tryAsync(async () => {
+                const msg = await thread.messages.fetch(pendingPerm.messageId);
+                await msg.edit({ components: [] });
+            });
+            if (removeButtonsResult instanceof Error) {
+                sessionLogger.log(`[PERMISSION] Failed to remove buttons for ${permId}:`, removeButtonsResult);
+            }
             if (!clientV2) {
                 sessionLogger.log(`[PERMISSION] OpenCode v2 client unavailable for permission ${permId}`);
                 cleanupPermissionContext(pendingPerm.contextHash);
-                rejectedCount++;
                 continue;
             }
             const rejectResult = await errore.tryAsync(() => {
@@ -400,16 +406,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             if (rejectResult instanceof Error) {
                 sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, rejectResult);
             }
-            else {
-                rejectedCount++;
-            }
             cleanupPermissionContext(pendingPerm.contextHash);
         }
         pendingPermissions.delete(thread.id);
-        if (rejectedCount > 0) {
-            const plural = rejectedCount > 1 ? 's' : '';
-            await sendThreadMessage(thread, `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected due to new message`);
-        }
     }
     // Answer any pending question tool with the user's message (silently, no thread message)
     const questionAnswered = await cancelPendingQuestion(thread.id, prompt);
@@ -1029,7 +1028,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(() => {
@@ -1205,7 +1204,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     sessionLogger.error('Failed to fetch provider info for context percentage:', contextResult);
                 }
                 const projectInfo = branchName ? `${folderName} ⋅ ${branchName} ⋅ ` : `${folderName} ⋅ `;
-                await sendThreadMessage(thread, `_${projectInfo}${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS });
+                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);
@@ -1217,7 +1216,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)