kimaki 0.4.46 → 0.4.48

package/dist/cli.js

@@ -10,13 +10,33 @@ import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuild
 import path from 'node:path';
 import fs from 'node:fs';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { uploadFilesToDiscord } from './discord-utils.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
-import { setDataDir, getDataDir, getLockPort } from './config.js';
+import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity } from './config.js';
 import { sanitizeAgentName } from './commands/agent.js';
-const cliLogger = createLogger('CLI');
+const cliLogger = createLogger(LogPrefix.CLI);
+// Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Not detached, so it dies automatically with the parent process.
+function startCaffeinate() {
+    if (process.platform !== 'darwin') {
+        return;
+    }
+    try {
+        const proc = spawn('caffeinate', ['-i'], {
+            stdio: 'ignore',
+            detached: false,
+        });
+        proc.on('error', (err) => {
+            cliLogger.warn('Failed to start caffeinate:', err.message);
+        });
+        cliLogger.log('Started caffeinate to prevent system sleep');
+    }
+    catch (err) {
+        cliLogger.warn('Failed to spawn caffeinate:', err instanceof Error ? err.message : String(err));
+    }
+}
 const cli = cac('kimaki');
 process.title = 'kimaki';
 async function killProcessOnPort(port) {
@@ -86,7 +106,8 @@ async function checkSingleInstance() {
             });
         }
     }
-    catch {
+    catch (error) {
+        cliLogger.debug('Lock port check failed:', error instanceof Error ? error.message : String(error));
         cliLogger.debug('No other kimaki instance detected on lock port');
     }
 }
@@ -217,6 +238,10 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .setName('abort')
             .setDescription('Abort the current OpenCode request in this thread')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('compact')
+            .setDescription('Compact the session context by summarizing conversation history')
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('stop')
             .setDescription('Abort the current OpenCode request in this thread')
@@ -375,11 +400,17 @@ async function backgroundInit({ currentDir, token, appId, }) {
             getClient()
                 .command.list({ query: { directory: currentDir } })
                 .then((r) => r.data || [])
-                .catch(() => []),
+                .catch((error) => {
+                cliLogger.warn('Failed to load user commands during background init:', error instanceof Error ? error.message : String(error));
+                return [];
+            }),
             getClient()
                 .app.agents({ query: { directory: currentDir } })
                 .then((r) => r.data || [])
-                .catch(() => []),
+                .catch((error) => {
+                cliLogger.warn('Failed to load agents during background init:', error instanceof Error ? error.message : String(error));
+                return [];
+            }),
         ]);
         await registerCommands({ token, appId, userCommands, agents });
         cliLogger.log('Slash commands registered!');
@@ -389,6 +420,7 @@ async function backgroundInit({ currentDir, token, appId, }) {
     }
 }
 async function run({ restart, addChannels, useWorktrees }) {
+    startCaffeinate();
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
     // Step 0: Check if OpenCode CLI is available
@@ -423,7 +455,8 @@ async function run({ restart, addChannels, useWorktrees }) {
                     fs.accessSync(p, fs.constants.F_OK);
                     return true;
                 }
-                catch {
+                catch (error) {
+                    cliLogger.debug(`OpenCode path not found at ${p}:`, error instanceof Error ? error.message : String(error));
                     return false;
                 }
             });
@@ -651,11 +684,17 @@ async function run({ restart, addChannels, useWorktrees }) {
         getClient()
             .command.list({ query: { directory: currentDir } })
             .then((r) => r.data || [])
-            .catch(() => []),
+            .catch((error) => {
+            cliLogger.warn('Failed to load user commands during setup:', error instanceof Error ? error.message : String(error));
+            return [];
+        }),
         getClient()
             .app.agents({ query: { directory: currentDir } })
             .then((r) => r.data || [])
-            .catch(() => []),
+            .catch((error) => {
+            cliLogger.warn('Failed to load agents during setup:', error instanceof Error ? error.message : String(error));
+            return [];
+        }),
     ]);
     s.stop(`Found ${projects.length} OpenCode project(s)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
@@ -766,6 +805,7 @@ cli
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
     .option('--install-url', 'Print the bot install URL and exit')
     .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
+    .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text or text-only)')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -773,6 +813,14 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.verbosity) {
+            if (options.verbosity !== 'tools-and-text' && options.verbosity !== 'text-only') {
+                cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use "tools-and-text" or "text-only".`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            setDefaultVerbosity(options.verbosity);
+            cliLogger.log(`Default verbosity: ${options.verbosity}`);
+        }
         if (options.installUrl) {
             const db = getDatabase();
             const existingBot = db
@@ -895,8 +943,8 @@ cli
                         .get();
                     appId = botRow?.app_id;
                 }
-                catch {
-                    // Database might not exist in CI, that's ok
+                catch (error) {
+                    cliLogger.debug('Database lookup failed while resolving app ID:', error instanceof Error ? error.message : String(error));
                 }
             }
         }
@@ -992,8 +1040,8 @@ cli
                                     return ch.guild;
                                 }
                             }
-                            catch {
-                                // Channel might be deleted, continue
+                            catch (error) {
+                                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.message : String(error));
                             }
                         }
                         // Fall back to first guild the bot is in
@@ -1174,8 +1222,8 @@ cli
                         .get();
                     appId = botRow?.app_id;
                 }
-                catch {
-                    // Database might not exist in CI
+                catch (error) {
+                    cliLogger.debug('Database lookup failed while resolving app ID:', error instanceof Error ? error.message : String(error));
                 }
             }
         }
@@ -1245,8 +1293,8 @@ cli
                         throw new Error('Channel has no guild');
                     }
                 }
-                catch {
-                    // Channel might be deleted, fall back to first guild
+                catch (error) {
+                    cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.message : String(error));
                     const firstGuild = client.guilds.cache.first();
                     if (!firstGuild) {
                         s.stop('No guild found');
@@ -1285,13 +1333,13 @@ cli
                         process.exit(0);
                     }
                 }
-                catch {
-                    // Channel might be deleted, continue checking
+                catch (error) {
+                    cliLogger.debug(`Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`, error instanceof Error ? error.message : String(error));
                 }
             }
         }
-        catch {
-            // Database might not exist, continue to create
+        catch (error) {
+            cliLogger.debug('Database lookup failed while checking existing channels:', error instanceof Error ? error.message : String(error));
         }
         s.message(`Creating channels in ${guild.name}...`);
         const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({

package/dist/commands/abort.js

@@ -4,9 +4,9 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { abortControllers } from '../session-handler.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const logger = createLogger('ABORT');
+const logger = createLogger(LogPrefix.ABORT);
 export async function handleAbortCommand({ command }) {
     const channel = command.channel;
     if (!channel) {
@@ -54,6 +54,7 @@ export async function handleAbortCommand({ command }) {
     const sessionId = row.session_id;
     const existingController = abortControllers.get(sessionId);
     if (existingController) {
+        logger.log(`[ABORT] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - user ran /abort command`);
         existingController.abort(new Error('User requested abort'));
         abortControllers.delete(sessionId);
     }
@@ -67,6 +68,7 @@ export async function handleAbortCommand({ command }) {
         return;
     }
     try {
+        logger.log(`[ABORT-API] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - sending API abort from /abort command`);
         await getClient().session.abort({
             path: { id: sessionId },
         });

package/dist/commands/add-project.js

@@ -4,10 +4,10 @@ import path from 'node:path';
 import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
 import * as errore from 'errore';
-const logger = createLogger('ADD-PROJECT');
+const logger = createLogger(LogPrefix.ADD_PROJECT);
 export async function handleAddProjectCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const projectId = command.options.getString('project', true);

package/dist/commands/agent.js

@@ -5,9 +5,9 @@ import crypto from 'node:crypto';
 import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runModelMigrations } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const agentLogger = createLogger('AGENT');
+const agentLogger = createLogger(LogPrefix.AGENT);
 const pendingAgentContexts = new Map();
 /**
  * Sanitize an agent name to be a valid Discord command name component.
@@ -181,7 +181,7 @@ export async function handleAgentSelectMenu(interaction) {
         }
         else {
             await interaction.editReply({
-                content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+                content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
                 components: [],
             });
         }
@@ -237,7 +237,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
         }
         else {
             await command.editReply({
-                content: `Switched to **${matchingAgent.name}** agent for this channel\n\nAll new sessions will use this agent.`,
+                content: `Switched to **${matchingAgent.name}** agent for this channel\nAll new sessions will use this agent.`,
             });
         }
     }

package/dist/commands/ask-question.js

@@ -5,8 +5,8 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
 import { getOpencodeClientV2 } from '../opencode.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('ASK_QUESTION');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.ASK_QUESTION);
 // Store pending question contexts by hash
 export const pendingQuestionContexts = new Map();
 /**
@@ -178,9 +178,9 @@ export function parseAskUserQuestionTool(part) {
 }
 /**
  * Cancel a pending question for a thread (e.g., when user sends a new message).
- * Sends cancellation response to OpenCode so the session can continue.
+ * Sends the user's message as the answer to OpenCode so the model sees their actual response.
  */
-export async function cancelPendingQuestion(threadId) {
+export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
     let contextHash;
     let context;
@@ -199,18 +199,19 @@ export async function cancelPendingQuestion(threadId) {
         if (!clientV2) {
             throw new Error('OpenCode server not found for directory');
         }
-        // Preserve already-answered questions, mark unanswered as cancelled
+        // Use user's message as answer if provided, otherwise mark as "Other"
+        const customAnswer = userMessage || 'Other';
         const answers = context.questions.map((_, i) => {
-            return context.answers[i] || ['(cancelled - user sent new message)'];
+            return context.answers[i] || [customAnswer];
         });
         await clientV2.question.reply({
             requestID: context.requestId,
             answers,
         });
-        logger.log(`Cancelled question ${context.requestId} due to new user message`);
+        logger.log(`Answered question ${context.requestId} with user message`);
     }
     catch (error) {
-        logger.error('Failed to cancel question:', error);
+        logger.error('Failed to answer question:', error);
     }
     // Clean up regardless of whether the API call succeeded
     pendingQuestionContexts.delete(contextHash);

package/dist/commands/compact.js

@@ -0,0 +1,126 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.COMPACT);
+export async function handleCompactCommand({ command }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        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,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        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,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    // Ensure server is running for this directory
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to compact: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(directory);
+    if (!clientV2) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Defer reply since compaction may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        // Get session messages to find the model from the last user message
+        const messagesResult = await clientV2.session.messages({
+            sessionID: sessionId,
+            directory,
+        });
+        if (messagesResult.error || !messagesResult.data) {
+            logger.error('[COMPACT] Failed to get messages:', messagesResult.error);
+            await command.editReply({
+                content: 'Failed to compact: Could not retrieve session messages',
+            });
+            return;
+        }
+        // Find the last user message to get the model
+        const lastUserMessage = [...messagesResult.data]
+            .reverse()
+            .find((msg) => msg.info.role === 'user');
+        if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+            await command.editReply({
+                content: 'Failed to compact: No user message found in session',
+            });
+            return;
+        }
+        const { providerID, modelID } = lastUserMessage.info.model;
+        const result = await clientV2.session.summarize({
+            sessionID: sessionId,
+            directory,
+            providerID,
+            modelID,
+            auto: false,
+        });
+        if (result.error) {
+            logger.error('[COMPACT] Error:', result.error);
+            const errorMessage = 'data' in result.error && result.error.data
+                ? result.error.data.message || 'Unknown error'
+                : 'Unknown error';
+            await command.editReply({
+                content: `Failed to compact: ${errorMessage}`,
+            });
+            return;
+        }
+        await command.editReply({
+            content: `📦 Session **compacted** successfully`,
+        });
+        logger.log(`Session ${sessionId} compacted by user`);
+    }
+    catch (error) {
+        logger.error('[COMPACT] Error:', error);
+        await command.editReply({
+            content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/create-new-project.js

@@ -1,13 +1,51 @@
 // /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 import { getProjectsDir } from '../config.js';
 import { createProjectChannels } from '../channel-management.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('CREATE-NEW-PROJECT');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.CREATE_PROJECT);
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({ guild, projectName, appId, botName, }) {
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        return null;
+    }
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+        logger.log(`Created projects directory: ${projectsDir}`);
+    }
+    if (fs.existsSync(projectDirectory)) {
+        return null;
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    logger.log(`Created project directory: ${projectDirectory}`);
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+    logger.log(`Initialized git in: ${projectDirectory}`);
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+        botName,
+    });
+    return { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName };
+}
 export async function handleCreateNewProjectCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
     const projectName = command.options.getString('name', true);
@@ -21,39 +59,31 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
         await command.editReply('This command can only be used in a text channel');
         return;
     }
-    const sanitizedName = projectName
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 100);
-    if (!sanitizedName) {
-        await command.editReply('Invalid project name');
-        return;
-    }
-    const projectsDir = getProjectsDir();
-    const projectDirectory = path.join(projectsDir, sanitizedName);
     try {
-        if (!fs.existsSync(projectsDir)) {
-            fs.mkdirSync(projectsDir, { recursive: true });
-            logger.log(`Created projects directory: ${projectsDir}`);
-        }
-        if (fs.existsSync(projectDirectory)) {
-            await command.editReply(`Project directory already exists: ${projectDirectory}`);
-            return;
-        }
-        fs.mkdirSync(projectDirectory, { recursive: true });
-        logger.log(`Created project directory: ${projectDirectory}`);
-        const { execSync } = await import('node:child_process');
-        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
-        logger.log(`Initialized git in: ${projectDirectory}`);
-        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        const result = await createNewProject({
             guild,
-            projectDirectory,
+            projectName,
             appId,
+            botName: command.client.user?.username,
         });
+        if (!result) {
+            const sanitizedName = projectName
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '')
+                .slice(0, 100);
+            if (!sanitizedName) {
+                await command.editReply('Invalid project name');
+                return;
+            }
+            const projectDirectory = path.join(getProjectsDir(), sanitizedName);
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result;
         const textChannel = (await guild.channels.fetch(textChannelId));
-        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`);
         const starterMessage = await textChannel.send({
             content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
             flags: SILENT_MESSAGE_FLAGS,

package/dist/commands/fork.js

@@ -4,10 +4,10 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const sessionLogger = createLogger('SESSION');
-const forkLogger = createLogger('FORK');
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const forkLogger = createLogger(LogPrefix.FORK);
 export async function handleForkCommand(interaction) {
     const channel = interaction.channel;
     if (!channel) {

package/dist/commands/merge-worktree.js

@@ -3,9 +3,9 @@
 // After merge, switches to detached HEAD at main so user can keep working.
 import {} from 'discord.js';
 import { getThreadWorktree } from '../database.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import { execAsync } from '../worktree-utils.js';
-const logger = createLogger('MERGE-WORKTREE');
+const logger = createLogger(LogPrefix.WORKTREE);
 /** Worktree thread title prefix - indicates unmerged worktree */
 export const WORKTREE_PREFIX = '⬦ ';
 /**
@@ -38,7 +38,8 @@ async function isDetachedHead(worktreeDir) {
         await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`);
         return false;
     }
-    catch {
+    catch (error) {
+        logger.debug(`Failed to resolve HEAD for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
         return true;
     }
 }
@@ -50,7 +51,8 @@ async function getCurrentBranch(worktreeDir) {
         const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
         return stdout.trim() || null;
     }
-    catch {
+    catch (error) {
+        logger.debug(`Failed to get current branch for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
         return null;
     }
 }
@@ -89,7 +91,8 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
             const { stdout } = await execAsync(`git -C "${mainRepoDir}" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`);
             defaultBranch = stdout.trim() || 'main';
         }
-        catch {
+        catch (error) {
+            logger.warn(`Failed to detect default branch for ${mainRepoDir}, falling back to main:`, error instanceof Error ? error.message : String(error));
             defaultBranch = 'main';
         }
         // 3. Determine if we're on a branch or detached HEAD
@@ -115,11 +118,17 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
         }
         catch (e) {
             // If merge fails (conflicts), abort and report
-            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => { });
+            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch((error) => {
+                logger.warn(`Failed to abort merge in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
             // Clean up temp branch if we created one
             if (tempBranch) {
-                await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch(() => { });
-                await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch(() => { });
+                await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch((error) => {
+                    logger.warn(`Failed to detach HEAD after merge conflict in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
+                await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch((error) => {
+                    logger.warn(`Failed to delete temp branch ${tempBranch} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
             }
             throw new Error(`Merge conflict - resolve manually in worktree then retry`);
         }
@@ -133,10 +142,14 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
         await execAsync(`git -C "${worktreeDir}" checkout --detach ${defaultBranch}`);
         // 7. Delete the merged branch (temp or original)
         logger.log(`Deleting merged branch ${branchToMerge}`);
-        await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch(() => { });
+        await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch((error) => {
+            logger.warn(`Failed to delete merged branch ${branchToMerge} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+        });
         // Also delete the original worktree branch if different from what we merged
         if (!isDetached && branchToMerge !== worktreeInfo.worktree_name) {
-            await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch(() => { });
+            await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch((error) => {
+                logger.warn(`Failed to delete worktree branch ${worktreeInfo.worktree_name} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
         }
         // 8. Remove worktree prefix from thread title (fire and forget with timeout)
         void removeWorktreePrefixFromTitle(thread);