kimaki 0.4.39 → 0.4.41

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kimaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import * as errore from 'errore';
 import { createLogger } 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';
@@ -136,7 +137,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
         })
             .toJSON(),
         new SlashCommandBuilder()
-            .setName('session')
+            .setName('new-session')
             .setDescription('Start a new OpenCode session')
             .addStringOption((option) => {
             option.setName('prompt').setDescription('Prompt content for the session').setRequired(true);
@@ -158,6 +159,17 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('new-worktree')
+            .setDescription('Create a new git worktree and start a session thread')
+            .addStringOption((option) => {
+            option
+                .setName('name')
+                .setDescription('Name for the worktree (will be formatted: lowercase, spaces to dashes)')
+                .setRequired(true);
+            return option;
+        })
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription('Create Discord channels for a new OpenCode project')
@@ -280,6 +292,79 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
         throw error;
     }
 }
+/**
+ * Store channel-directory mappings in the database.
+ * Called after Discord login to persist channel configurations.
+ */
+function storeChannelDirectories({ kimakiChannels, db, }) {
+    for (const { guild, channels } of kimakiChannels) {
+        for (const channel of channels) {
+            if (channel.kimakiDirectory) {
+                db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)').run(channel.id, channel.kimakiDirectory, 'text', channel.kimakiApp || null);
+                const voiceChannel = guild.channels.cache.find((ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name);
+                if (voiceChannel) {
+                    db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)').run(voiceChannel.id, channel.kimakiDirectory, 'voice', channel.kimakiApp || null);
+                }
+            }
+        }
+    }
+}
+/**
+ * Show the ready message with channel links.
+ * Called at the end of startup to display available channels.
+ */
+function showReadyMessage({ kimakiChannels, createdChannels, appId, }) {
+    const allChannels = [];
+    allChannels.push(...createdChannels);
+    kimakiChannels.forEach(({ guild, channels }) => {
+        channels.forEach((ch) => {
+            allChannels.push({
+                name: ch.name,
+                id: ch.id,
+                guildId: guild.id,
+                directory: ch.kimakiDirectory,
+            });
+        });
+    });
+    if (allChannels.length > 0) {
+        const channelLinks = allChannels
+            .map((ch) => `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`)
+            .join('\n');
+        note(`Your kimaki channels are ready! Click any link below to open in Discord:\n\n${channelLinks}\n\nSend a message in any channel to start using OpenCode!`, '🚀 Ready to Use');
+    }
+    note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
+}
+/**
+ * Background initialization for quick start mode.
+ * Starts OpenCode server and registers slash commands without blocking bot startup.
+ */
+async function backgroundInit({ currentDir, token, appId, }) {
+    try {
+        const opencodeResult = await initializeOpencodeForDirectory(currentDir);
+        if (opencodeResult instanceof Error) {
+            cliLogger.warn('Background OpenCode init failed:', opencodeResult.message);
+            // Still try to register basic commands without user commands/agents
+            await registerCommands({ token, appId, userCommands: [], agents: [] });
+            return;
+        }
+        const getClient = opencodeResult;
+        const [userCommands, agents] = await Promise.all([
+            getClient()
+                .command.list({ query: { directory: currentDir } })
+                .then((r) => r.data || [])
+                .catch(() => []),
+            getClient()
+                .app.agents({ query: { directory: currentDir } })
+                .then((r) => r.data || [])
+                .catch(() => []),
+        ]);
+        await registerCommands({ token, appId, userCommands, agents });
+        cliLogger.log('Slash commands registered!');
+    }
+    catch (error) {
+        cliLogger.error('Background init failed:', error instanceof Error ? error.message : String(error));
+    }
+}
 async function run({ restart, addChannels }) {
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
@@ -434,7 +519,7 @@ async function run({ restart, addChannels }) {
     const currentDir = process.cwd();
     s.start('Starting OpenCode server...');
     const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
-        if (errore.isError(result)) {
+        if (result instanceof Error) {
             throw new Error(result.message);
         }
         return result;
@@ -500,17 +585,8 @@ async function run({ restart, addChannels }) {
         process.exit(EXIT_NO_RESTART);
     }
     db.prepare('INSERT OR REPLACE INTO bot_tokens (app_id, token) VALUES (?, ?)').run(appId, token);
-    for (const { guild, channels } of kimakiChannels) {
-        for (const channel of channels) {
-            if (channel.kimakiDirectory) {
-                db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)').run(channel.id, channel.kimakiDirectory, 'text', channel.kimakiApp || null);
-                const voiceChannel = guild.channels.cache.find((ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name);
-                if (voiceChannel) {
-                    db.prepare('INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)').run(voiceChannel.id, channel.kimakiDirectory, 'voice', channel.kimakiApp || null);
-                }
-            }
-        }
-    }
+    // Store channel-directory mappings
+    storeChannelDirectories({ kimakiChannels, db });
     if (kimakiChannels.length > 0) {
         const channelList = kimakiChannels
             .flatMap(({ guild, channels }) => channels.map((ch) => {
@@ -520,6 +596,19 @@ async function run({ restart, addChannels }) {
             .join('\n');
         note(channelList, 'Existing Kimaki Channels');
     }
+    // Quick start: if setup is already done, start bot immediately and background the rest
+    const isQuickStart = existingBot && !forceSetup && !addChannels;
+    if (isQuickStart) {
+        s.start('Starting Discord bot...');
+        await startDiscordBot({ token, appId, discordClient });
+        s.stop('Discord bot is running!');
+        // Background: OpenCode init + slash command registration (non-blocking)
+        void backgroundInit({ currentDir, token, appId });
+        showReadyMessage({ kimakiChannels, createdChannels, appId });
+        outro('✨ Bot ready! Listening for messages...');
+        return;
+    }
+    // Full setup path: wait for OpenCode, show prompts, create channels if needed
     // Await the OpenCode server that was started in parallel with Discord login
     s.start('Waiting for OpenCode server...');
     const getClient = await opencodePromise;
@@ -644,25 +733,7 @@ async function run({ restart, addChannels }) {
     s.start('Starting Discord bot...');
     await startDiscordBot({ token, appId, discordClient });
     s.stop('Discord bot is running!');
-    const allChannels = [];
-    allChannels.push(...createdChannels);
-    kimakiChannels.forEach(({ guild, channels }) => {
-        channels.forEach((ch) => {
-            allChannels.push({
-                name: ch.name,
-                id: ch.id,
-                guildId: guild.id,
-                directory: ch.kimakiDirectory,
-            });
-        });
-    });
-    if (allChannels.length > 0) {
-        const channelLinks = allChannels
-            .map((ch) => `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`)
-            .join('\n');
-        note(`Your kimaki channels are ready! Click any link below to open in Discord:\n\n${channelLinks}\n\nSend a message in any channel to start using OpenCode!`, '🚀 Ready to Use');
-    }
-    note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
+    showReadyMessage({ kimakiChannels, createdChannels, appId });
     outro('✨ Setup complete! Listening for new messages... do not close this process.');
 }
 cli
@@ -741,25 +812,11 @@ cli
         }
         const s = spinner();
         s.start(`Uploading ${resolvedFiles.length} file(s)...`);
-        for (const file of resolvedFiles) {
-            const buffer = fs.readFileSync(file);
-            const formData = new FormData();
-            formData.append('payload_json', JSON.stringify({
-                attachments: [{ id: 0, filename: path.basename(file) }],
-            }));
-            formData.append('files[0]', new Blob([buffer]), path.basename(file));
-            const response = await fetch(`https://discord.com/api/v10/channels/${threadRow.thread_id}/messages`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bot ${botRow.token}`,
-                },
-                body: formData,
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                throw new Error(`Discord API error: ${response.status} - ${error}`);
-            }
-        }
+        await uploadFilesToDiscord({
+            threadId: threadRow.thread_id,
+            botToken: botRow.token,
+            files: resolvedFiles,
+        });
         s.stop(`Uploaded ${resolvedFiles.length} file(s)!`);
         note(`Files uploaded to Discord thread!\n\nFiles: ${resolvedFiles.map((f) => path.basename(f)).join(', ')}`, '✅ Success');
         process.exit(0);

package/dist/commands/abort.js

@@ -58,7 +58,7 @@ export async function handleAbortCommand({ command }) {
         abortControllers.delete(sessionId);
     }
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.reply({
             content: `Failed to abort: ${getClient.message}`,
             ephemeral: true,

package/dist/commands/add-project.js

@@ -19,7 +19,7 @@ export async function handleAddProjectCommand({ command, appId }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -65,7 +65,7 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/agent.js

@@ -103,7 +103,7 @@ export async function handleAgentCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({ content: getClient.message });
             return;
         }
@@ -210,7 +210,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply({ content: getClient.message });
             return;
         }

package/dist/commands/fork.js

@@ -52,7 +52,7 @@ export async function handleForkCommand(interaction) {
     await interaction.deferReply({ ephemeral: true });
     const sessionId = row.session_id;
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await interaction.editReply({
             content: `Failed to load messages: ${getClient.message}`,
         });
@@ -128,7 +128,7 @@ export async function handleForkSelectMenu(interaction) {
     }
     await interaction.deferReply({ ephemeral: false });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await interaction.editReply(`Failed to fork session: ${getClient.message}`);
         return;
     }

package/dist/commands/model.js

@@ -78,7 +78,7 @@ export async function handleModelCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({ content: getClient.message });
             return;
         }
@@ -167,7 +167,7 @@ export async function handleProviderSelectMenu(interaction) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.editReply({
                 content: getClient.message,
                 components: [],

package/dist/commands/remove-project.js

@@ -30,7 +30,7 @@ export async function handleRemoveProjectCommand({ command, appId }) {
                 try: () => guild.channels.fetch(channel_id),
                 catch: (e) => e,
             });
-            if (errore.isError(channel)) {
+            if (channel instanceof Error) {
                 logger.error(`Failed to fetch channel ${channel_id}:`, channel);
                 failedChannels.push(`${channel_type}: ${channel_id}`);
                 continue;
@@ -88,7 +88,7 @@ export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
                 try: () => guild.channels.fetch(channel_id),
                 catch: (e) => e,
             });
-            if (errore.isError(channel)) {
+            if (channel instanceof Error) {
                 // Channel not in this guild, skip
                 continue;
             }

package/dist/commands/resume.js

@@ -42,7 +42,7 @@ export async function handleResumeCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -116,7 +116,7 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/session.js

@@ -1,4 +1,4 @@
-// /session command - Start a new OpenCode session.
+// /new-session command - Start a new OpenCode session.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -45,7 +45,7 @@ export async function handleSessionCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await command.editReply(getClient.message);
             return;
         }
@@ -107,7 +107,7 @@ async function handleAgentAutocomplete({ interaction, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }
@@ -174,7 +174,7 @@ export async function handleSessionAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (errore.isError(getClient)) {
+        if (getClient instanceof Error) {
             await interaction.respond([]);
             return;
         }

package/dist/commands/share.js

@@ -52,7 +52,7 @@ export async function handleShareCommand({ command }) {
     }
     const sessionId = row.session_id;
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.reply({
             content: `Failed to share session: ${getClient.message}`,
             ephemeral: true,

package/dist/commands/undo-redo.js

@@ -53,7 +53,7 @@ export async function handleUndoCommand({ command }) {
     const sessionId = row.session_id;
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.editReply(`Failed to undo: ${getClient.message}`);
         return;
     }
@@ -140,7 +140,7 @@ export async function handleRedoCommand({ command }) {
     const sessionId = row.session_id;
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await command.editReply(`Failed to redo: ${getClient.message}`);
         return;
     }

package/dist/commands/worktree.js

@@ -0,0 +1,180 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
+// Creates thread immediately, then worktree in background so user can type
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { extractTagsArrays } from '../xml.js';
+import { createLogger } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger('WORKTREE');
+class WorktreeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'WorktreeError';
+    }
+}
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
+ * "My Feature" → "kimaki-my-feature"
+ */
+function formatWorktreeName(name) {
+    const formatted = name
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    return `kimaki-${formatted}`;
+}
+/**
+ * Get project directory from channel topic.
+ */
+function getProjectDirectoryFromChannel(channel, appId) {
+    if (!channel.topic) {
+        return new WorktreeError('This channel has no topic configured');
+    }
+    const extracted = extractTagsArrays({
+        xml: channel.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+    });
+    const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+    const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+    if (channelAppId && channelAppId !== appId) {
+        return new WorktreeError('This channel is not configured for this bot');
+    }
+    if (!projectDirectory) {
+        return new WorktreeError('This channel is not configured with a project directory');
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        return new WorktreeError(`Directory does not exist: ${projectDirectory}`);
+    }
+    return projectDirectory;
+}
+/**
+ * Create worktree in background and update starter message when done.
+ */
+async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, }) {
+    // Create worktree using SDK v2
+    logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`);
+    const worktreeResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.create({
+                directory: projectDirectory,
+                worktreeCreateInput: {
+                    name: worktreeName,
+                },
+            });
+            if (response.error) {
+                throw new Error(`SDK error: ${JSON.stringify(response.error)}`);
+            }
+            if (!response.data) {
+                throw new Error('No worktree data returned from SDK');
+            }
+            return response.data;
+        },
+        catch: (e) => new WorktreeError('Failed to create worktree', { cause: e }),
+    });
+    if (errore.isError(worktreeResult)) {
+        const errorMsg = worktreeResult.message;
+        logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause);
+        setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+        await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
+        return;
+    }
+    // Success - update database and edit starter message
+    setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory });
+    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n` +
+        `📁 \`${worktreeResult.directory}\`\n` +
+        `🌿 Branch: \`${worktreeResult.branch}\``);
+}
+export async function handleNewWorktreeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const rawName = command.options.getString('name', true);
+    const worktreeName = formatWorktreeName(rawName);
+    if (worktreeName === 'kimaki-') {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+        return;
+    }
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels');
+        return;
+    }
+    const textChannel = channel;
+    const projectDirectory = getProjectDirectoryFromChannel(textChannel, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode and check if worktree already exists
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    // SDK returns array of directory paths like "~/.opencode/worktree/abc/kimaki-my-feature"
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    // Check if any worktree path ends with our name
+    const existingWorktree = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktree) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``);
+        return;
+    }
+    // Create thread immediately so user can start typing
+    const result = await errore.tryAsync({
+        try: async () => {
+            const starterMessage = await textChannel.send({
+                content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const thread = await starterMessage.startThread({
+                name: `worktree: ${worktreeName}`,
+                autoArchiveDuration: 1440,
+                reason: 'Worktree session',
+            });
+            return { thread, starterMessage };
+        },
+        catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+    });
+    if (errore.isError(result)) {
+        logger.error('[NEW-WORKTREE] Error:', result.cause);
+        await command.editReply(result.message);
+        return;
+    }
+    const { thread, starterMessage } = result;
+    // Store pending worktree in database
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    await command.editReply(`Creating worktree in ${thread.toString()}`);
+    // Create worktree in background (don't await)
+    createWorktreeInBackground({
+        thread,
+        starterMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}