kimaki 0.4.42 → 0.4.44

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

package/src/session-handler.ts

@@ -13,6 +13,7 @@ import {
   getSessionAgent,
   getChannelAgent,
   setSessionAgent,
+  getThreadWorktree,
 } from './database.js'
 import {
   initializeOpencodeForDirectory,
@@ -21,7 +22,7 @@ import {
 } from './opencode.js'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
-import { getOpencodeSystemMessage } from './system-message.js'
+import { getOpencodeSystemMessage, type WorktreeInfo } from './system-message.js'
 import { createLogger } from './logger.js'
 import { isAbortError } from './utils.js'
 import {
@@ -38,9 +39,12 @@ const discordLogger = createLogger('DISCORD')
 
 export const abortControllers = new Map<string, AbortController>()
 
+// 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<
-  string,
-  { permission: PermissionRequest; messageId: string; directory: string; contextHash: string }
+  string, // threadId
+  Map<string, { permission: PermissionRequest; messageId: string; directory: string; contextHash: string }> // permissionId -> data
 >()
 
 export type QueuedMessage = {
@@ -246,30 +250,34 @@ export async function handleOpencodeSession({
     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)
+    }
+    pendingPermissions.delete(thread.id)
+    if (rejectedCount > 0) {
+      const plural = rejectedCount > 1 ? 's' : ''
       await sendThreadMessage(
         thread,
-        `⚠️ Previous permission request auto-rejected due to new message`,
+        `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected due to new message`,
       )
-    } catch (e) {
-      sessionLogger.log(`[PERMISSION] Failed to auto-reject permission:`, e)
-      cleanupPermissionContext(pendingPerm.contextHash)
-      pendingPermissions.delete(thread.id)
     }
   }
 
@@ -536,7 +544,7 @@ export async function handleOpencodeSession({
             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()
             }
@@ -612,7 +620,7 @@ export async function handleOpencodeSession({
               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()
             }, 300)
@@ -650,6 +658,15 @@ export async function handleOpencodeSession({
             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(', ')}`,
           )
@@ -667,7 +684,11 @@ export async function handleOpencodeSession({
             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,
@@ -681,10 +702,18 @@ export async function handleOpencodeSession({
 
           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') {
           const questionRequest = event.properties
@@ -951,6 +980,17 @@ export async function handleOpencodeSession({
       return { providerID, modelID }
     })()
 
+    // Get worktree info if this thread is in a worktree
+    const worktreeInfo = getThreadWorktree(thread.id)
+    const worktree: WorktreeInfo | undefined =
+      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({
@@ -966,7 +1006,7 @@ export async function handleOpencodeSession({
           path: { id: session.id },
           body: {
             parts,
-            system: getOpencodeSystemMessage({ sessionId: session.id, channelId }),
+            system: getOpencodeSystemMessage({ sessionId: session.id, channelId, worktree }),
             model: modelParam,
             agent: agentPreference,
           },