kimaki 0.4.43 → 0.4.44

package/dist/cli.js

@@ -170,6 +170,18 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('merge-worktree')
+            .setDescription('Merge the worktree branch into the default branch')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('enable-worktrees')
+            .setDescription('Enable automatic git worktree creation for new sessions in this channel')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('disable-worktrees')
+            .setDescription('Disable automatic git worktree creation for new sessions in this channel')
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription('Create Discord channels for a new OpenCode project')
@@ -365,7 +377,7 @@ async function backgroundInit({ currentDir, token, appId, }) {
         cliLogger.error('Background init failed:', error instanceof Error ? error.message : String(error));
     }
 }
-async function run({ restart, addChannels }) {
+async function run({ restart, addChannels, useWorktrees }) {
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
     // Step 0: Check if OpenCode CLI is available
@@ -600,7 +612,7 @@ async function run({ restart, addChannels }) {
     const isQuickStart = existingBot && !forceSetup && !addChannels;
     if (isQuickStart) {
         s.start('Starting Discord bot...');
-        await startDiscordBot({ token, appId, discordClient });
+        await startDiscordBot({ token, appId, discordClient, useWorktrees });
         s.stop('Discord bot is running!');
         // Background: OpenCode init + slash command registration (non-blocking)
         void backgroundInit({ currentDir, token, appId });
@@ -731,7 +743,7 @@ async function run({ restart, addChannels }) {
         cliLogger.error('Failed to register slash commands:', error instanceof Error ? error.message : String(error));
     });
     s.start('Starting Discord bot...');
-    await startDiscordBot({ token, appId, discordClient });
+    await startDiscordBot({ token, appId, discordClient, useWorktrees });
     s.stop('Discord bot is running!');
     showReadyMessage({ kimakiChannels, createdChannels, appId });
     outro('✨ Setup complete! Listening for new messages... do not close this process.');
@@ -742,6 +754,7 @@ cli
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
     .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')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -767,6 +780,7 @@ cli
             restart: options.restart,
             addChannels: options.addChannels,
             dataDir: options.dataDir,
+            useWorktrees: options.useWorktrees,
         });
     }
     catch (error) {
@@ -1031,6 +1045,12 @@ cli
         // If prompt exceeds this, send it as a file attachment instead.
         const DISCORD_MAX_LENGTH = 2000;
         let starterMessage;
+        // Embed marker for auto-start sessions (unless --notify-only)
+        // Bot checks for this embed footer to know it should start a session
+        const AUTO_START_MARKER = 'kimaki:start';
+        const autoStartEmbed = notifyOnly
+            ? undefined
+            : [{ color: 0x2b2d31, footer: { text: AUTO_START_MARKER } }];
         if (prompt.length > DISCORD_MAX_LENGTH) {
             // Send as file attachment with a short summary
             const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
@@ -1048,6 +1068,7 @@ cli
                 formData.append('payload_json', JSON.stringify({
                     content: summaryContent,
                     attachments: [{ id: 0, filename: 'prompt.md' }],
+                    embeds: autoStartEmbed,
                 }));
                 const buffer = fs.readFileSync(tmpFile);
                 formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
@@ -1080,6 +1101,7 @@ cli
                 },
                 body: JSON.stringify({
                     content: prompt,
+                    embeds: autoStartEmbed,
                 }),
             });
             if (!starterMessageResponse.ok) {
@@ -1109,17 +1131,6 @@ cli
             throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
         }
         const threadData = (await threadResponse.json());
-        // Mark thread for auto-start if not notify-only
-        // This is optional - only works if local database exists (for local bot auto-start)
-        if (!notifyOnly) {
-            try {
-                const db = getDatabase();
-                db.prepare('INSERT OR REPLACE INTO pending_auto_start (thread_id) VALUES (?)').run(threadData.id);
-            }
-            catch {
-                // Database not available (e.g., CI environment) - skip auto-start marking
-            }
-        }
         s.stop('Thread created!');
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
         const successMessage = notifyOnly
@@ -1134,5 +1145,155 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('add-project [directory]', 'Create Discord channels for a project directory')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
+    .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
+    .action(async (directory, options) => {
+    try {
+        const absolutePath = path.resolve(directory || '.');
+        if (!fs.existsSync(absolutePath)) {
+            cliLogger.error(`Directory does not exist: ${absolutePath}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Get bot token from env var or database
+        const envToken = process.env.KIMAKI_BOT_TOKEN;
+        let botToken;
+        let appId = options.appId;
+        if (envToken) {
+            botToken = envToken;
+            if (!appId) {
+                try {
+                    const db = getDatabase();
+                    const botRow = db
+                        .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                        .get();
+                    appId = botRow?.app_id;
+                }
+                catch {
+                    // Database might not exist in CI
+                }
+            }
+        }
+        else {
+            try {
+                const db = getDatabase();
+                const botRow = db
+                    .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                    .get();
+                if (botRow) {
+                    botToken = botRow.token;
+                    appId = appId || botRow.app_id;
+                }
+            }
+            catch (e) {
+                cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
+            }
+        }
+        if (!botToken) {
+            cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!appId) {
+            cliLogger.error('App ID is required to create channels. Use --app-id or run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start('Checking for existing channel...');
+        // Check if channel already exists
+        try {
+            const db = getDatabase();
+            const existingChannel = db
+                .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?')
+                .get(absolutePath, 'text', appId);
+            if (existingChannel) {
+                s.stop('Channel already exists');
+                note(`Channel already exists for this directory.\n\nChannel: <#${existingChannel.channel_id}>\nDirectory: ${absolutePath}`, '⚠️  Already Exists');
+                process.exit(0);
+            }
+        }
+        catch {
+            // Database might not exist, continue to create
+        }
+        s.message('Connecting to Discord...');
+        const client = await createDiscordClient();
+        await new Promise((resolve, reject) => {
+            client.once(Events.ClientReady, () => {
+                resolve();
+            });
+            client.once(Events.Error, reject);
+            client.login(botToken);
+        });
+        s.message('Finding guild...');
+        // Find guild
+        let guild;
+        if (options.guild) {
+            const foundGuild = client.guilds.cache.get(options.guild);
+            if (!foundGuild) {
+                s.stop('Guild not found');
+                cliLogger.error(`Guild not found: ${options.guild}`);
+                client.destroy();
+                process.exit(EXIT_NO_RESTART);
+            }
+            guild = foundGuild;
+        }
+        else {
+            // Auto-detect: prefer guild with existing channels for this bot, else first guild
+            const db = getDatabase();
+            const existingChannelRow = db
+                .prepare('SELECT channel_id FROM channel_directories WHERE app_id = ? ORDER BY created_at DESC LIMIT 1')
+                .get(appId);
+            if (existingChannelRow) {
+                try {
+                    const ch = await client.channels.fetch(existingChannelRow.channel_id);
+                    if (ch && 'guild' in ch && ch.guild) {
+                        guild = ch.guild;
+                    }
+                    else {
+                        throw new Error('Channel has no guild');
+                    }
+                }
+                catch {
+                    // Channel might be deleted, fall back to first guild
+                    const firstGuild = client.guilds.cache.first();
+                    if (!firstGuild) {
+                        s.stop('No guild found');
+                        cliLogger.error('No guild found. Add the bot to a server first.');
+                        client.destroy();
+                        process.exit(EXIT_NO_RESTART);
+                    }
+                    guild = firstGuild;
+                }
+            }
+            else {
+                const firstGuild = client.guilds.cache.first();
+                if (!firstGuild) {
+                    s.stop('No guild found');
+                    cliLogger.error('No guild found. Add the bot to a server first.');
+                    client.destroy();
+                    process.exit(EXIT_NO_RESTART);
+                }
+                guild = firstGuild;
+            }
+        }
+        s.message(`Creating channels in ${guild.name}...`);
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: absolutePath,
+            appId,
+            botName: client.user?.username,
+        });
+        client.destroy();
+        s.stop('Channels created!');
+        const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
+        note(`Created channels for project:\n\n📝 Text: #${channelName}\n🔊 Voice: #${channelName}\n📁 Directory: ${absolutePath}\n\nURL: ${channelUrl}`, '✅ Success');
+        console.log(channelUrl);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli.help();
 cli.parse();

package/dist/commands/merge-worktree.js

@@ -0,0 +1,152 @@
+// /merge-worktree command - Merge worktree commits into main/default branch.
+// Handles both branch-based worktrees and detached HEAD state.
+// 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 { execAsync } from '../worktree-utils.js';
+const logger = createLogger('MERGE-WORKTREE');
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ ';
+/**
+ * Remove the worktree prefix from a thread title.
+ * Uses Promise.race with timeout since Discord thread title updates can hang.
+ */
+async function removeWorktreePrefixFromTitle(thread) {
+    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+        return;
+    }
+    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    // Race between the edit and a timeout - thread title updates are heavily rate-limited
+    const timeoutMs = 5000;
+    const editPromise = thread.setName(newName).catch((e) => {
+        logger.warn(`Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`);
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            logger.warn(`Thread title update timed out after ${timeoutMs}ms`);
+            resolve();
+        }, timeoutMs);
+    });
+    await Promise.race([editPromise, timeoutPromise]);
+}
+/**
+ * Check if worktree is in detached HEAD state.
+ */
+async function isDetachedHead(worktreeDir) {
+    try {
+        await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Get current branch name (returns null if detached).
+ */
+async function getCurrentBranch(worktreeDir) {
+    try {
+        const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleMergeWorktreeCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const channel = command.channel;
+    // Must be in a thread
+    if (!channel || !channel.isThread()) {
+        await command.editReply('This command can only be used in a thread');
+        return;
+    }
+    const thread = channel;
+    // Get worktree info from database
+    const worktreeInfo = getThreadWorktree(thread.id);
+    if (!worktreeInfo) {
+        await command.editReply('This thread is not associated with a worktree');
+        return;
+    }
+    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+        return;
+    }
+    const mainRepoDir = worktreeInfo.project_directory;
+    const worktreeDir = worktreeInfo.worktree_directory;
+    try {
+        // 1. Check for uncommitted changes
+        const { stdout: status } = await execAsync(`git -C "${worktreeDir}" status --porcelain`);
+        if (status.trim()) {
+            await command.editReply(`❌ Uncommitted changes detected in worktree.\n\nPlease commit your changes first, then retry \`/merge-worktree\`.`);
+            return;
+        }
+        // 2. Get the default branch name
+        logger.log(`Getting default branch for ${mainRepoDir}`);
+        let defaultBranch;
+        try {
+            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 {
+            defaultBranch = 'main';
+        }
+        // 3. Determine if we're on a branch or detached HEAD
+        const isDetached = await isDetachedHead(worktreeDir);
+        const currentBranch = await getCurrentBranch(worktreeDir);
+        let branchToMerge;
+        let tempBranch = null;
+        if (isDetached) {
+            // Create a temporary branch from detached HEAD
+            tempBranch = `temp-merge-${Date.now()}`;
+            logger.log(`Detached HEAD detected, creating temp branch: ${tempBranch}`);
+            await execAsync(`git -C "${worktreeDir}" checkout -b ${tempBranch}`);
+            branchToMerge = tempBranch;
+        }
+        else {
+            branchToMerge = currentBranch || worktreeInfo.worktree_name;
+        }
+        logger.log(`Default branch: ${defaultBranch}, branch to merge: ${branchToMerge}`);
+        // 4. Merge default branch INTO worktree (handles diverged branches)
+        logger.log(`Merging ${defaultBranch} into worktree at ${worktreeDir}`);
+        try {
+            await execAsync(`git -C "${worktreeDir}" merge ${defaultBranch} --no-edit`);
+        }
+        catch (e) {
+            // If merge fails (conflicts), abort and report
+            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => { });
+            // 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(() => { });
+            }
+            throw new Error(`Merge conflict - resolve manually in worktree then retry`);
+        }
+        // 5. Update default branch ref to point to current HEAD
+        // Use update-ref instead of fetch because fetch refuses if branch is checked out
+        logger.log(`Updating ${defaultBranch} to point to current HEAD`);
+        const { stdout: commitHash } = await execAsync(`git -C "${worktreeDir}" rev-parse HEAD`);
+        await execAsync(`git -C "${mainRepoDir}" update-ref refs/heads/${defaultBranch} ${commitHash.trim()}`);
+        // 6. Switch to detached HEAD at default branch (allows main to be checked out elsewhere)
+        logger.log(`Switching to detached HEAD at ${defaultBranch}`);
+        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(() => { });
+        // 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(() => { });
+        }
+        // 8. Remove worktree prefix from thread title (fire and forget with timeout)
+        void removeWorktreePrefixFromTitle(thread);
+        const sourceDesc = isDetached ? 'detached commits' : `\`${branchToMerge}\``;
+        await command.editReply(`✅ Merged ${sourceDesc} into \`${defaultBranch}\`\n\nWorktree now at detached HEAD - you can keep working here.`);
+        logger.log(`Successfully merged ${branchToMerge} into ${defaultBranch}`);
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        logger.error(`Merge failed: ${errorMsg}`);
+        await command.editReply(`❌ Merge failed:\n\`\`\`\n${errorMsg}\n\`\`\``);
+    }
+}

package/dist/commands/worktree-settings.js

@@ -0,0 +1,88 @@
+// /enable-worktrees and /disable-worktrees commands.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelWorktreesEnabled, setChannelWorktreesEnabled } from '../database.js';
+import { getKimakiMetadata } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const worktreeSettingsLogger = createLogger('WORKTREE_SETTINGS');
+/**
+ * Handle the /enable-worktrees slash command.
+ * Enables automatic worktree creation for new sessions in this channel.
+ */
+export async function handleEnableWorktreesCommand({ command, appId, }) {
+    worktreeSettingsLogger.log('[ENABLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nAdd a `<kimaki.directory>/path/to/project</kimaki.directory>` tag to the channel description.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = getChannelWorktreesEnabled(textChannel.id);
+    setChannelWorktreesEnabled(textChannel.id, true);
+    worktreeSettingsLogger.log(`[ENABLE_WORKTREES] Enabled for channel ${textChannel.id}`);
+    await command.reply({
+        content: wasEnabled
+            ? `Worktrees are already enabled for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will automatically create git worktrees.`
+            : `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nUse \`/disable-worktrees\` to turn this off.`,
+        ephemeral: true,
+    });
+}
+/**
+ * Handle the /disable-worktrees slash command.
+ * Disables automatic worktree creation for new sessions in this channel.
+ */
+export async function handleDisableWorktreesCommand({ command, appId, }) {
+    worktreeSettingsLogger.log('[DISABLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nAdd a `<kimaki.directory>/path/to/project</kimaki.directory>` tag to the channel description.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = getChannelWorktreesEnabled(textChannel.id);
+    setChannelWorktreesEnabled(textChannel.id, false);
+    worktreeSettingsLogger.log(`[DISABLE_WORKTREES] Disabled for channel ${textChannel.id}`);
+    await command.reply({
+        content: wasEnabled
+            ? `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nUse \`/enable-worktrees\` to turn this back on.`
+            : `Worktrees are already disabled for this channel.\n\nNew sessions will use the main project directory.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/worktree.js

@@ -8,6 +8,8 @@ import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { extractTagsArrays } from '../xml.js';
 import { createLogger } from '../logger.js';
+import { createWorktreeWithSubmodules } from '../worktree-utils.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 const logger = createLogger('WORKTREE');
 class WorktreeError extends Error {
@@ -17,16 +19,16 @@ class WorktreeError extends Error {
     }
 }
 /**
- * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
- * "My Feature" → "kimaki-my-feature"
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
  */
-function formatWorktreeName(name) {
+export function formatWorktreeName(name) {
     const formatted = name
         .toLowerCase()
         .trim()
         .replace(/\s+/g, '-')
         .replace(/[^a-z0-9-]/g, '');
-    return `kimaki-${formatted}`;
+    return `opencode/kimaki-${formatted}`;
 }
 /**
  * Get project directory from channel topic.
@@ -56,29 +58,16 @@ function getProjectDirectoryFromChannel(channel, appId) {
  * Create worktree in background and update starter message when done.
  */
 async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, }) {
-    // Create worktree using SDK v2
+    // Create worktree using SDK v2 and init submodules
     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 }),
+    const worktreeResult = await createWorktreeWithSubmodules({
+        clientV2,
+        directory: projectDirectory,
+        name: worktreeName,
     });
-    if (errore.isError(worktreeResult)) {
+    if (worktreeResult instanceof Error) {
         const errorMsg = worktreeResult.message;
-        logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause);
+        logger.error('[NEW-WORKTREE] Error:', worktreeResult);
         setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
         await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
         return;
@@ -146,7 +135,7 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
                 flags: SILENT_MESSAGE_FLAGS,
             });
             const thread = await starterMessage.startThread({
-                name: `worktree: ${worktreeName}`,
+                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
                 autoArchiveDuration: 1440,
                 reason: 'Worktree session',
             });

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();