kimaki 0.4.42 → 0.4.44

package/dist/database.js

@@ -90,6 +90,7 @@ export function getDatabase() {
       )
     `);
         runModelMigrations(db);
+        runWorktreeSettingsMigrations(db);
     }
     return db;
 }
@@ -250,6 +251,41 @@ export function deleteThreadWorktree(threadId) {
     const db = getDatabase();
     db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId);
 }
+/**
+ * Run migrations for channel worktree settings table.
+ * Called on startup. Allows per-channel opt-in for automatic worktree creation.
+ */
+export function runWorktreeSettingsMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_worktrees (
+      channel_id TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Channel worktree settings migrations complete');
+}
+/**
+ * Check if automatic worktree creation is enabled for a channel.
+ */
+export function getChannelWorktreesEnabled(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT enabled FROM channel_worktrees WHERE channel_id = ?')
+        .get(channelId);
+    return row?.enabled === 1;
+}
+/**
+ * Enable or disable automatic worktree creation for a channel.
+ */
+export function setChannelWorktreesEnabled(channelId, enabled) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_worktrees (channel_id, enabled, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET enabled = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,8 +1,11 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { getDatabase, closeDatabase, getThreadWorktree } from './database.js';
-import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
+import { getDatabase, closeDatabase, getThreadWorktree, createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelWorktreesEnabled, } from './database.js';
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js';
+import { formatWorktreeName } from './commands/worktree.js';
+import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
+import { createWorktreeWithSubmodules } from './worktree-utils.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { getFileAttachments, getTextAttachments } from './message-formatting.js';
@@ -39,7 +42,7 @@ export async function createDiscordClient() {
         partials: [Partials.Channel, Partials.Message, Partials.User, Partials.ThreadMember],
     });
 }
-export async function startDiscordBot({ token, appId, discordClient, }) {
+export async function startDiscordBot({ token, appId, discordClient, useWorktrees, }) {
     if (!discordClient) {
         discordClient = await createDiscordClient();
     }
@@ -299,20 +302,76 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     return;
                 }
                 const hasVoice = message.attachments.some((a) => a.contentType?.startsWith('audio/'));
-                const threadName = hasVoice
+                const baseThreadName = hasVoice
                     ? 'Voice Message'
                     : message.content?.replace(/\s+/g, ' ').trim() || 'Claude Thread';
+                // Check if worktrees should be enabled (CLI flag OR channel setting)
+                const shouldUseWorktrees = useWorktrees || getChannelWorktreesEnabled(textChannel.id);
+                // Add worktree prefix if worktrees are enabled
+                const threadName = shouldUseWorktrees
+                    ? `${WORKTREE_PREFIX}${baseThreadName}`
+                    : baseThreadName;
                 const thread = await message.startThread({
                     name: threadName.slice(0, 80),
                     autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
                     reason: 'Start Claude session',
                 });
                 discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
+                // Create worktree if worktrees are enabled (CLI flag OR channel setting)
+                let sessionDirectory = projectDirectory;
+                if (shouldUseWorktrees) {
+                    const worktreeName = formatWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
+                    discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+                    // Store pending worktree immediately so bot knows about it
+                    createPendingWorktree({
+                        threadId: thread.id,
+                        worktreeName,
+                        projectDirectory,
+                    });
+                    // Initialize OpenCode and create worktree
+                    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                    if (getClient instanceof Error) {
+                        discordLogger.error(`[WORKTREE] Failed to init OpenCode: ${getClient.message}`);
+                        setWorktreeError({ threadId: thread.id, errorMessage: getClient.message });
+                        await thread.send({
+                            content: `⚠️ Failed to create worktree: ${getClient.message}\nUsing main project directory instead.`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                    }
+                    else {
+                        const clientV2 = getOpencodeClientV2(projectDirectory);
+                        if (!clientV2) {
+                            discordLogger.error(`[WORKTREE] No v2 client for ${projectDirectory}`);
+                            setWorktreeError({ threadId: thread.id, errorMessage: 'No OpenCode v2 client' });
+                        }
+                        else {
+                            const worktreeResult = await createWorktreeWithSubmodules({
+                                clientV2,
+                                directory: projectDirectory,
+                                name: worktreeName,
+                            });
+                            if (worktreeResult instanceof Error) {
+                                const errMsg = worktreeResult.message;
+                                discordLogger.error(`[WORKTREE] Creation failed: ${errMsg}`);
+                                setWorktreeError({ threadId: thread.id, errorMessage: errMsg });
+                                await thread.send({
+                                    content: `⚠️ Failed to create worktree: ${errMsg}\nUsing main project directory instead.`,
+                                    flags: SILENT_MESSAGE_FLAGS,
+                                });
+                            }
+                            else {
+                                setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory });
+                                sessionDirectory = worktreeResult.directory;
+                                discordLogger.log(`[WORKTREE] Created: ${worktreeResult.directory} (branch: ${worktreeResult.branch})`);
+                            }
+                        }
+                    }
+                }
                 let messageContent = message.content || '';
                 const transcription = await processVoiceAttachment({
                     message,
                     thread,
-                    projectDirectory,
+                    projectDirectory: sessionDirectory,
                     isNewThread: true,
                     appId: currentAppId,
                 });
@@ -327,7 +386,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 await handleOpencodeSession({
                     prompt: promptWithAttachments,
                     thread,
-                    projectDirectory,
+                    projectDirectory: sessionDirectory,
                     originalMessage: message,
                     images: fileAttachments,
                     channelId: textChannel.id,
@@ -349,33 +408,30 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
         }
     });
     // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
+    // Uses embed marker instead of database to avoid race conditions
+    const AUTO_START_MARKER = 'kimaki:start';
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
         try {
             if (!newlyCreated) {
                 return;
             }
-            // Check if this thread is marked for auto-start in the database
-            const db = getDatabase();
-            const pendingRow = db
-                .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
-                .get(thread.id);
-            if (!pendingRow) {
-                return; // Not a CLI-initiated auto-start thread
-            }
-            // Remove from pending table
-            db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id);
-            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
             // Only handle threads in text channels
             const parent = thread.parent;
             if (!parent || parent.type !== ChannelType.GuildText) {
                 return;
             }
-            // Get the starter message for the prompt
+            // Get the starter message to check for auto-start marker
             const starterMessage = await thread.fetchStarterMessage().catch(() => null);
             if (!starterMessage) {
                 discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`);
                 return;
             }
+            // Check if starter message has the auto-start embed marker
+            const hasAutoStartMarker = starterMessage.embeds.some((embed) => embed.footer?.text === AUTO_START_MARKER);
+            if (!hasAutoStartMarker) {
+                return; // Not a CLI-initiated auto-start thread
+            }
+            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
             const prompt = starterMessage.content.trim();
             if (!prompt) {
                 discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);

package/dist/interaction-handler.js

@@ -4,6 +4,8 @@
 import { Events } from 'discord.js';
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js';
 import { handleNewWorktreeCommand } from './commands/worktree.js';
+import { handleMergeWorktreeCommand } from './commands/merge-worktree.js';
+import { handleEnableWorktreesCommand, handleDisableWorktreesCommand, } from './commands/worktree-settings.js';
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -57,6 +59,15 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'new-worktree':
                         await handleNewWorktreeCommand({ command: interaction, appId });
                         return;
+                    case 'merge-worktree':
+                        await handleMergeWorktreeCommand({ command: interaction, appId });
+                        return;
+                    case 'enable-worktrees':
+                        await handleEnableWorktreesCommand({ command: interaction, appId });
+                        return;
+                    case 'disable-worktrees':
+                        await handleDisableWorktreesCommand({ command: interaction, appId });
+                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;

package/dist/session-handler.js

@@ -2,7 +2,7 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
-import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, } from './database.js';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2, } from './opencode.js';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
@@ -16,6 +16,9 @@ const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
 const discordLogger = createLogger('DISCORD');
 export const abortControllers = new Map();
+// Track multiple pending permissions per thread (keyed by permission ID)
+// OpenCode handles blocking/sequencing - we just need to track all pending permissions
+// to avoid duplicates and properly clean up on auto-reject
 export const pendingPermissions = new Map();
 // Queue of messages waiting to be sent after current response finishes
 // Key is threadId, value is array of queued messages
@@ -148,26 +151,32 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
         existingController.abort(new Error('New request started'));
     }
-    const pendingPerm = pendingPermissions.get(thread.id);
-    if (pendingPerm) {
-        try {
-            sessionLogger.log(`[PERMISSION] Auto-rejecting pending permission ${pendingPerm.permission.id} due to new message`);
-            const clientV2 = getOpencodeClientV2(directory);
-            if (clientV2) {
-                await clientV2.permission.reply({
-                    requestID: pendingPerm.permission.id,
-                    reply: 'reject',
-                });
+    // Auto-reject ALL pending permissions for this thread
+    const threadPermissions = pendingPermissions.get(thread.id);
+    if (threadPermissions && threadPermissions.size > 0) {
+        const clientV2 = getOpencodeClientV2(directory);
+        let rejectedCount = 0;
+        for (const [permId, pendingPerm] of threadPermissions) {
+            try {
+                sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`);
+                if (clientV2) {
+                    await clientV2.permission.reply({
+                        requestID: permId,
+                        reply: 'reject',
+                    });
+                }
+                cleanupPermissionContext(pendingPerm.contextHash);
+                rejectedCount++;
+            }
+            catch (e) {
+                sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, e);
+                cleanupPermissionContext(pendingPerm.contextHash);
             }
-            // Clean up both the pending permission and its dropdown context
-            cleanupPermissionContext(pendingPerm.contextHash);
-            pendingPermissions.delete(thread.id);
-            await sendThreadMessage(thread, `⚠️ Previous permission request auto-rejected due to new message`);
         }
-        catch (e) {
-            sessionLogger.log(`[PERMISSION] Failed to auto-reject permission:`, e);
-            cleanupPermissionContext(pendingPerm.contextHash);
-            pendingPermissions.delete(thread.id);
+        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`);
         }
     }
     // Cancel any pending question tool if user sends a new message (silently, no thread message)
@@ -382,7 +391,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     if (part.type === 'step-start') {
                         // Don't start typing if user needs to respond to a question or permission
                         const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
-                        const hasPendingPermission = pendingPermissions.has(thread.id);
+                        const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
                         if (!hasPendingQuestion && !hasPendingPermission) {
                             stopTyping = startTyping();
                         }
@@ -451,7 +460,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                 return;
                             // Don't restart typing if user needs to respond to a question or permission
                             const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
-                            const hasPendingPermission = pendingPermissions.has(thread.id);
+                            const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
                             if (hasPendingQuestion || hasPendingPermission)
                                 return;
                             stopTyping = startTyping();
@@ -487,6 +496,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
                         continue;
                     }
+                    // Skip if this exact permission ID is already pending (dedupe)
+                    const threadPermissions = pendingPermissions.get(thread.id);
+                    if (threadPermissions?.has(permission.id)) {
+                        sessionLogger.log(`[PERMISSION] Skipping duplicate permission ${permission.id} (already pending)`);
+                        continue;
+                    }
                     sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
                     // Stop typing - user needs to respond now, not the bot
                     if (stopTyping) {
@@ -499,7 +514,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         permission,
                         directory,
                     });
-                    pendingPermissions.set(thread.id, {
+                    // Track permission in nested map (threadId -> permissionId -> data)
+                    if (!pendingPermissions.has(thread.id)) {
+                        pendingPermissions.set(thread.id, new Map());
+                    }
+                    pendingPermissions.get(thread.id).set(permission.id, {
                         permission,
                         messageId,
                         directory,
@@ -512,10 +531,18 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         continue;
                     }
                     sessionLogger.log(`Permission ${requestID} replied with: ${reply}`);
-                    const pending = pendingPermissions.get(thread.id);
-                    if (pending && pending.permission.id === requestID) {
-                        cleanupPermissionContext(pending.contextHash);
-                        pendingPermissions.delete(thread.id);
+                    // Clean up the specific permission from nested map
+                    const threadPermissions = pendingPermissions.get(thread.id);
+                    if (threadPermissions) {
+                        const pending = threadPermissions.get(requestID);
+                        if (pending) {
+                            cleanupPermissionContext(pending.contextHash);
+                            threadPermissions.delete(requestID);
+                            // Remove thread entry if no more pending permissions
+                            if (threadPermissions.size === 0) {
+                                pendingPermissions.delete(thread.id);
+                            }
+                        }
                     }
                 }
                 else if (event.type === 'question.asked') {
@@ -728,6 +755,15 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
             return { providerID, modelID };
         })();
+        // Get worktree info if this thread is in a worktree
+        const worktreeInfo = getThreadWorktree(thread.id);
+        const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+            ? {
+                worktreeDirectory: worktreeInfo.worktree_directory,
+                branch: worktreeInfo.worktree_name,
+                mainRepoDirectory: worktreeInfo.project_directory,
+            }
+            : undefined;
         // Use session.command API for slash commands, session.prompt for regular messages
         const response = command
             ? await getClient().session.command({
@@ -743,7 +779,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 path: { id: session.id },
                 body: {
                     parts,
-                    system: getOpencodeSystemMessage({ sessionId: session.id, channelId }),
+                    system: getOpencodeSystemMessage({ sessionId: session.id, channelId, worktree }),
                     model: modelParam,
                     agent: agentPreference,
                 },

package/dist/system-message.js

@@ -1,7 +1,7 @@
 // OpenCode system prompt generator.
 // Creates the system message injected into every OpenCode session,
 // including Discord-specific formatting rules, diff commands, and permissions info.
-export function getOpencodeSystemMessage({ sessionId, channelId, }) {
+export function getOpencodeSystemMessage({ sessionId, channelId, worktree, }) {
     return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
@@ -35,6 +35,41 @@ Use --notify-only to create a notification thread without starting an AI session
 npx -y kimaki send --channel ${channelId} --prompt "User cancelled subscription" --notify-only
 
 This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
+
+### Session handoff
+
+When you are approaching the **context window limit** or the user explicitly asks to **handoff to a new thread**, use the \`kimaki send\` command to start a fresh session with context:
+
+\`\`\`bash
+npx -y kimaki send --channel ${channelId} --prompt "Continuing from previous session: <summary of current task and state>"
+\`\`\`
+
+The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+
+Use this for handoff when:
+- User asks to "handoff", "continue in new thread", or "start fresh session"
+- You detect you're running low on context window space
+- A complex task would benefit from a clean slate with summarized context
+`
+        : ''}${worktree
+        ? `
+## worktree
+
+This session is running inside a git worktree.
+- **Worktree path:** \`${worktree.worktreeDirectory}\`
+- **Branch:** \`${worktree.branch}\`
+- **Main repo:** \`${worktree.mainRepoDirectory}\`
+
+Before finishing a task, ask the user if they want to merge changes back to the main branch.
+
+To merge (without leaving the worktree):
+\`\`\`bash
+# Get the default branch name
+DEFAULT_BRANCH=$(git -C ${worktree.mainRepoDirectory} symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
+
+# Merge worktree branch into main
+git -C ${worktree.mainRepoDirectory} checkout $DEFAULT_BRANCH && git -C ${worktree.mainRepoDirectory} merge ${worktree.branch}
+\`\`\`
 `
         : ''}
 ## showing diffs
@@ -43,20 +78,24 @@ IMPORTANT: After editing any files, you MUST execute the critique command using
 
 Execute this after making changes:
 
-bunx critique web --title "Add user authentication flow"
+bunx critique --web "Add user authentication flow"
 
 If there are other unrelated changes in the working directory, filter to only show the files you edited:
 
-bunx critique web --title "Fix database connection retry" -- path/to/file1.ts path/to/file2.ts
+bunx critique --web "Fix database connection retry" --filter "path/to/file1.ts" --filter "path/to/file2.ts"
 
 You can also show latest commit changes using:
 
-bunx critique web --title "Refactor API endpoints" HEAD
+bunx critique HEAD --web "Refactor API endpoints"
 
-bunx critique web --title "Update dependencies" HEAD~1 to get the one before last
+bunx critique HEAD~1 --web "Update dependencies"
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 
+To compare two branches:
+
+bunx critique main feature-branch --web "Compare branches"
+
 The command outputs a URL - share that URL with the user so they can see the diff.
 
 ## markdown

package/dist/voice-handler.js

@@ -375,6 +375,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             EmptyTranscriptionError: (e) => e.message,
             NoResponseContentError: (e) => e.message,
             NoToolResponseError: (e) => e.message,
+            Error: (e) => e.message,
         });
         voiceLogger.error(`Transcription failed:`, transcription);
         await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`);

package/dist/worktree-utils.js

@@ -0,0 +1,50 @@
+// Worktree utility functions.
+// Wrapper for OpenCode worktree creation that also initializes git submodules.
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createLogger } from './logger.js';
+export const execAsync = promisify(exec);
+const logger = createLogger('WORKTREE-UTILS');
+/**
+ * Create a worktree using OpenCode SDK and initialize git submodules.
+ * This wrapper ensures submodules are properly set up in new worktrees.
+ */
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, }) {
+    // 1. Create worktree via OpenCode SDK
+    const response = await clientV2.worktree.create({
+        directory,
+        worktreeCreateInput: { name },
+    });
+    if (response.error) {
+        return new Error(`SDK error: ${JSON.stringify(response.error)}`);
+    }
+    if (!response.data) {
+        return new Error('No worktree data returned from SDK');
+    }
+    const worktreeDir = response.data.directory;
+    // 2. Init submodules in new worktree (don't block on failure)
+    try {
+        logger.log(`Initializing submodules in ${worktreeDir}`);
+        await execAsync('git submodule update --init --recursive', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Submodules initialized in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - submodules might not exist
+        logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // 3. Install dependencies using ni (detects package manager from lockfile)
+    try {
+        logger.log(`Installing dependencies in ${worktreeDir}`);
+        await execAsync('npx -y ni', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Dependencies installed in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - might not be a JS project or might fail for various reasons
+        logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return response.data;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.42",
+  "version": "0.4.44",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -41,7 +41,7 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1",
-    "errore": "^0.8.0"
+    "errore": "^0.9.0"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",