kimaki 0.4.43 → 0.4.44

package/src/commands/merge-worktree.ts

@@ -0,0 +1,186 @@
+// /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 { type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.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: ThreadChannel): Promise<void> {
+  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<void>((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: string): Promise<boolean> {
+  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: string): Promise<string | null> {
+  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 }: CommandContext): Promise<void> {
+  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 as ThreadChannel
+
+  // 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: string
+
+    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: string
+    let tempBranch: string | null = 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/src/commands/worktree-settings.ts

@@ -0,0 +1,122 @@
+// /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, type TextChannel } 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,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  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 as TextChannel
+  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,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  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 as TextChannel
+  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/src/commands/worktree.ts

@@ -14,6 +14,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')
@@ -26,17 +28,17 @@ 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: string): string {
+export function formatWorktreeName(name: string): string {
   const formatted = name
     .toLowerCase()
     .trim()
     .replace(/\s+/g, '-')
     .replace(/[^a-z0-9-]/g, '')
 
-  return `kimaki-${formatted}`
+  return `opencode/kimaki-${formatted}`
 }
 
 /**
@@ -89,33 +91,17 @@ async function createWorktreeInBackground({
   projectDirectory: string
   clientV2: ReturnType<typeof getOpencodeClientV2> & {}
 }): Promise<void> {
-  // 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
@@ -203,7 +189,7 @@ export async function handleNewWorktreeCommand({
       })
 
       const thread = await starterMessage.startThread({
-        name: `worktree: ${worktreeName}`,
+        name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
         autoArchiveDuration: 1440,
         reason: 'Worktree session',
       })

package/src/database.ts

@@ -105,6 +105,7 @@ export function getDatabase(): Database.Database {
     `)
 
     runModelMigrations(db)
+    runWorktreeSettingsMigrations(db)
   }
 
   return db
@@ -338,6 +339,48 @@ export function deleteThreadWorktree(threadId: string): void {
   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?: Database.Database): void {
+  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: string): boolean {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT enabled FROM channel_worktrees WHERE channel_id = ?')
+    .get(channelId) as { enabled: number } | undefined
+  return row?.enabled === 1
+}
+
+/**
+ * Enable or disable automatic worktree creation for a channel.
+ */
+export function setChannelWorktreesEnabled(channelId: string, enabled: boolean): void {
+  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(): void {
   if (db) {
     db.close()

package/src/discord-bot.ts

@@ -2,8 +2,19 @@
 // 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,
@@ -69,6 +80,8 @@ const voiceLogger = createLogger('VOICE')
 type StartOptions = {
   token: string
   appId?: string
+  /** When true, all new sessions from channel messages create git worktrees */
+  useWorktrees?: boolean
 }
 
 export async function createDiscordClient() {
@@ -87,6 +100,7 @@ export async function startDiscordBot({
   token,
   appId,
   discordClient,
+  useWorktrees,
 }: StartOptions & { discordClient?: Client }) {
   if (!discordClient) {
     discordClient = await createDiscordClient()
@@ -401,10 +415,18 @@ export async function startDiscordBot({
 
         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,
@@ -413,12 +435,65 @@ export async function startDiscordBot({
 
         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,
         })
@@ -434,7 +509,7 @@ export async function startDiscordBot({
         await handleOpencodeSession({
           prompt: promptWithAttachments,
           thread,
-          projectDirectory,
+          projectDirectory: sessionDirectory,
           originalMessage: message,
           images: fileAttachments,
           channelId: textChannel.id,
@@ -454,40 +529,37 @@ export async function startDiscordBot({
   })
 
   // 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) as { thread_id: string } | undefined
-
-      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 as TextChannel | null
       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/src/interaction-handler.ts

@@ -5,6 +5,11 @@
 import { Events, type Client, type Interaction } 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 {
@@ -87,6 +92,18 @@ export function registerInteractionHandler({
             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