kimaki 0.4.46 → 0.4.47

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.46",
+  "version": "0.4.47",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [

package/src/cli.ts

@@ -43,14 +43,34 @@ import path from 'node:path'
 import fs from 'node:fs'
 import * as errore from 'errore'
 
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { uploadFilesToDiscord } from './discord-utils.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
 import { sanitizeAgentName } from './commands/agent.js'
 
-const cliLogger = createLogger('CLI')
+const cliLogger = createLogger(LogPrefix.CLI)
+
+// Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Not detached, so it dies automatically with the parent process.
+function startCaffeinate() {
+  if (process.platform !== 'darwin') {
+    return
+  }
+  try {
+    const proc = spawn('caffeinate', ['-i'], {
+      stdio: 'ignore',
+      detached: false,
+    })
+    proc.on('error', (err) => {
+      cliLogger.warn('Failed to start caffeinate:', err.message)
+    })
+    cliLogger.log('Started caffeinate to prevent system sleep')
+  } catch (err) {
+    cliLogger.warn('Failed to spawn caffeinate:', err instanceof Error ? err.message : String(err))
+  }
+}
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
@@ -301,6 +321,10 @@ async function registerCommands({
       .setName('abort')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('compact')
+      .setDescription('Compact the session context by summarizing conversation history')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('stop')
       .setDescription('Abort the current OpenCode request in this thread')
@@ -545,6 +569,8 @@ async function backgroundInit({
 }
 
 async function run({ restart, addChannels, useWorktrees }: CliOptions) {
+  startCaffeinate()
+
   const forceSetup = Boolean(restart)
 
   intro('🤖 Discord Bot Setup')

package/src/commands/abort.ts

@@ -6,10 +6,10 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { abortControllers } from '../session-handler.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('ABORT')
+const logger = createLogger(LogPrefix.ABORT)
 
 export async function handleAbortCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel

package/src/commands/add-project.ts

@@ -6,11 +6,11 @@ import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { createProjectChannels } from '../channel-management.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { abbreviatePath } from '../utils.js'
 import * as errore from 'errore'
 
-const logger = createLogger('ADD-PROJECT')
+const logger = createLogger(LogPrefix.ADD_PROJECT)
 
 export async function handleAddProjectCommand({ command, appId }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })

package/src/commands/agent.ts

@@ -14,10 +14,10 @@ import crypto from 'node:crypto'
 import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runModelMigrations } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const agentLogger = createLogger('AGENT')
+const agentLogger = createLogger(LogPrefix.AGENT)
 
 const pendingAgentContexts = new Map<
   string,
@@ -257,7 +257,7 @@ export async function handleAgentSelectMenu(
       })
     } else {
       await interaction.editReply({
-        content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+        content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
         components: [],
       })
     }
@@ -331,7 +331,7 @@ export async function handleQuickAgentCommand({
       })
     } else {
       await command.editReply({
-        content: `Switched to **${matchingAgent.name}** agent for this channel\n\nAll new sessions will use this agent.`,
+        content: `Switched to **${matchingAgent.name}** agent for this channel\nAll new sessions will use this agent.`,
       })
     }
   } catch (error) {

package/src/commands/ask-question.ts

@@ -11,9 +11,9 @@ import {
 import crypto from 'node:crypto'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
 import { getOpencodeClientV2 } from '../opencode.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const logger = createLogger('ASK_QUESTION')
+const logger = createLogger(LogPrefix.ASK_QUESTION)
 
 // Schema matching the question tool input
 export type AskUserQuestionInput = {
@@ -268,9 +268,9 @@ export function parseAskUserQuestionTool(part: {
 
 /**
  * Cancel a pending question for a thread (e.g., when user sends a new message).
- * Sends cancellation response to OpenCode so the session can continue.
+ * Sends the user's message as the answer to OpenCode so the model sees their actual response.
  */
-export async function cancelPendingQuestion(threadId: string): Promise<boolean> {
+export async function cancelPendingQuestion(threadId: string, userMessage?: string): Promise<boolean> {
   // Find pending question for this thread
   let contextHash: string | undefined
   let context: PendingQuestionContext | undefined
@@ -292,9 +292,10 @@ export async function cancelPendingQuestion(threadId: string): Promise<boolean>
       throw new Error('OpenCode server not found for directory')
     }
 
-    // Preserve already-answered questions, mark unanswered as cancelled
+    // Use user's message as answer if provided, otherwise mark as "Other"
+    const customAnswer = userMessage || 'Other'
     const answers = context.questions.map((_, i) => {
-      return context.answers[i] || ['(cancelled - user sent new message)']
+      return context.answers[i] || [customAnswer]
     })
 
     await clientV2.question.reply({
@@ -302,9 +303,9 @@ export async function cancelPendingQuestion(threadId: string): Promise<boolean>
       answers,
     })
 
-    logger.log(`Cancelled question ${context.requestId} due to new user message`)
+    logger.log(`Answered question ${context.requestId} with user message`)
   } catch (error) {
-    logger.error('Failed to cancel question:', error)
+    logger.error('Failed to answer question:', error)
   }
 
   // Clean up regardless of whether the API call succeeded

package/src/commands/compact.ts

@@ -0,0 +1,148 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.COMPACT)
+
+export async function handleCompactCommand({ command }: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const textChannel = await resolveTextChannel(channel as ThreadChannel)
+  const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+  if (!directory) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await command.reply({
+      content: 'No active session in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const sessionId = row.session_id
+
+  // Ensure server is running for this directory
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to compact: ${getClient.message}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const clientV2 = getOpencodeClientV2(directory)
+  if (!clientV2) {
+    await command.reply({
+      content: 'Failed to get OpenCode client',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Defer reply since compaction may take a moment
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    // Get session messages to find the model from the last user message
+    const messagesResult = await clientV2.session.messages({
+      sessionID: sessionId,
+      directory,
+    })
+
+    if (messagesResult.error || !messagesResult.data) {
+      logger.error('[COMPACT] Failed to get messages:', messagesResult.error)
+      await command.editReply({
+        content: 'Failed to compact: Could not retrieve session messages',
+      })
+      return
+    }
+
+    // Find the last user message to get the model
+    const lastUserMessage = [...messagesResult.data]
+      .reverse()
+      .find((msg) => msg.info.role === 'user')
+
+    if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+      await command.editReply({
+        content: 'Failed to compact: No user message found in session',
+      })
+      return
+    }
+
+    const { providerID, modelID } = lastUserMessage.info.model
+
+    const result = await clientV2.session.summarize({
+      sessionID: sessionId,
+      directory,
+      providerID,
+      modelID,
+      auto: false,
+    })
+
+    if (result.error) {
+      logger.error('[COMPACT] Error:', result.error)
+      const errorMessage = 'data' in result.error && result.error.data
+        ? (result.error.data as { message?: string }).message || 'Unknown error'
+        : 'Unknown error'
+      await command.editReply({
+        content: `Failed to compact: ${errorMessage}`,
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `📦 Session **compacted** successfully`,
+    })
+    logger.log(`Session ${sessionId} compacted by user`)
+  } catch (error) {
+    logger.error('[COMPACT] Error:', error)
+    await command.editReply({
+      content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}

package/src/commands/create-new-project.ts

@@ -8,9 +8,9 @@ import { getProjectsDir } from '../config.js'
 import { createProjectChannels } from '../channel-management.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const logger = createLogger('CREATE-NEW-PROJECT')
+const logger = createLogger(LogPrefix.CREATE_PROJECT)
 
 export async function handleCreateNewProjectCommand({
   command,
@@ -74,7 +74,7 @@ export async function handleCreateNewProjectCommand({
     const textChannel = (await guild.channels.fetch(textChannelId)) as TextChannel
 
     await command.editReply(
-      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`,
+      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`,
     )
 
     const starterMessage = await textChannel.send({

package/src/commands/fork.ts

@@ -13,11 +13,11 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const sessionLogger = createLogger('SESSION')
-const forkLogger = createLogger('FORK')
+const sessionLogger = createLogger(LogPrefix.SESSION)
+const forkLogger = createLogger(LogPrefix.FORK)
 
 export async function handleForkCommand(interaction: ChatInputCommandInteraction): Promise<void> {
   const channel = interaction.channel

package/src/commands/merge-worktree.ts

@@ -5,10 +5,10 @@
 import { type ThreadChannel } from 'discord.js'
 import type { CommandContext } from './types.js'
 import { getThreadWorktree } from '../database.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { execAsync } from '../worktree-utils.js'
 
-const logger = createLogger('MERGE-WORKTREE')
+const logger = createLogger(LogPrefix.WORKTREE)
 
 /** Worktree thread title prefix - indicates unmerged worktree */
 export const WORKTREE_PREFIX = '⬦ '

package/src/commands/model.ts

@@ -14,10 +14,10 @@ import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } fro
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { abortAndRetrySession } from '../session-handler.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const modelLogger = createLogger('MODEL')
+const modelLogger = createLogger(LogPrefix.MODEL)
 
 // Store context by hash to avoid customId length limits (Discord max: 100 chars)
 const pendingModelContexts = new Map<
@@ -385,12 +385,12 @@ export async function handleModelSelectMenu(
 
       if (retried) {
         await interaction.editReply({
-          content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+          content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\n_Retrying current request with new model..._`,
           components: [],
         })
       } else {
         await interaction.editReply({
-          content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+          content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\``,
           components: [],
         })
       }
@@ -400,7 +400,7 @@ export async function handleModelSelectMenu(
       modelLogger.log(`Set model ${fullModelId} for channel ${context.channelId}`)
 
       await interaction.editReply({
-        content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\nAll new sessions in this channel will use this model.`,
+        content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\nAll new sessions in this channel will use this model.`,
         components: [],
       })
     }

package/src/commands/permissions.ts

@@ -12,9 +12,9 @@ import crypto from 'node:crypto'
 import type { PermissionRequest } from '@opencode-ai/sdk/v2'
 import { getOpencodeClientV2 } from '../opencode.js'
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const logger = createLogger('PERMISSIONS')
+const logger = createLogger(LogPrefix.PERMISSIONS)
 
 type PendingPermissionContext = {
   permission: PermissionRequest

package/src/commands/queue.ts

@@ -16,9 +16,9 @@ import {
   getQueueLength,
   clearQueue,
 } from '../session-handler.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const logger = createLogger('QUEUE')
+const logger = createLogger(LogPrefix.QUEUE)
 
 export async function handleQueueCommand({ command }: CommandContext): Promise<void> {
   const message = command.options.getString('message', true)

package/src/commands/remove-project.ts

@@ -4,10 +4,10 @@ import path from 'node:path'
 import * as errore from 'errore'
 import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { abbreviatePath } from '../utils.js'
 
-const logger = createLogger('REMOVE-PROJECT')
+const logger = createLogger(LogPrefix.REMOVE_PROJECT)
 
 export async function handleRemoveProjectCommand({ command, appId }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })

package/src/commands/resume.ts

@@ -12,10 +12,10 @@ import { getDatabase, getChannelDirectory } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('RESUME')
+const logger = createLogger(LogPrefix.RESUME)
 
 export async function handleResumeCommand({ command, appId }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })

package/src/commands/session.ts

@@ -8,10 +8,10 @@ import { getDatabase, getChannelDirectory } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { handleOpencodeSession } from '../session-handler.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('SESSION')
+const logger = createLogger(LogPrefix.SESSION)
 
 export async function handleSessionCommand({ command, appId }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })

package/src/commands/share.ts

@@ -5,10 +5,10 @@ import type { CommandContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('SHARE')
+const logger = createLogger(LogPrefix.SHARE)
 
 export async function handleShareCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel

package/src/commands/undo-redo.ts

@@ -5,10 +5,10 @@ import type { CommandContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('UNDO-REDO')
+const logger = createLogger(LogPrefix.UNDO_REDO)
 
 export async function handleUndoCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel

package/src/commands/user-command.ts

@@ -5,11 +5,11 @@ import type { CommandContext, CommandHandler } from './types.js'
 import { ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { getDatabase, getChannelDirectory } from '../database.js'
 import fs from 'node:fs'
 
-const userCommandLogger = createLogger('USER_CMD')
+const userCommandLogger = createLogger(LogPrefix.USER_CMD)
 
 export const handleUserCommand: CommandHandler = async ({ command, appId }: CommandContext) => {
   const discordCommandName = command.commandName

package/src/commands/verbosity.ts

@@ -5,9 +5,9 @@
 
 import { ChatInputCommandInteraction, ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
 import { getChannelVerbosity, setChannelVerbosity, type VerbosityLevel } from '../database.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const verbosityLogger = createLogger('VERBOSITY')
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY)
 
 /**
  * Handle the /verbosity slash command.
@@ -65,7 +65,7 @@ export async function handleVerbosityCommand({
     : 'All output will be shown, including tool executions and status messages.'
 
   await command.reply({
-    content: `Verbosity set to **${level}**.\n\n${description}\n\nThis applies to all new sessions in this channel.`,
+    content: `Verbosity set to **${level}**.\n${description}\nThis applies to all new sessions in this channel.`,
     ephemeral: true,
   })
 }

package/src/commands/worktree-settings.ts

@@ -5,9 +5,9 @@
 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'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const worktreeSettingsLogger = createLogger('WORKTREE_SETTINGS')
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE)
 
 /**
  * Handle the /enable-worktrees slash command.

package/src/commands/worktree.ts

@@ -14,12 +14,12 @@ import {
 } from '../database.js'
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
-import { createWorktreeWithSubmodules } from '../worktree-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { createWorktreeWithSubmodules, captureGitDiff, type CapturedDiff } from '../worktree-utils.js'
 import { WORKTREE_PREFIX } from './merge-worktree.js'
 import * as errore from 'errore'
 
-const logger = createLogger('WORKTREE')
+const logger = createLogger(LogPrefix.WORKTREE)
 
 class WorktreeError extends Error {
   constructor(message: string, options?: { cause?: unknown }) {
@@ -91,6 +91,7 @@ function getProjectDirectoryFromChannel(
 
 /**
  * Create worktree in background and update starter message when done.
+ * If diff is provided, it's applied during worktree creation (before submodule init).
  */
 async function createWorktreeInBackground({
   thread,
@@ -98,19 +99,22 @@ async function createWorktreeInBackground({
   worktreeName,
   projectDirectory,
   clientV2,
+  diff,
 }: {
   thread: ThreadChannel
   starterMessage: Message
   worktreeName: string
   projectDirectory: string
   clientV2: ReturnType<typeof getOpencodeClientV2> & {}
+  diff?: CapturedDiff | null
 }): Promise<void> {
-  // Create worktree using SDK v2 and init submodules
+  // Create worktree using SDK v2, apply diff, then init submodules
   logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`)
   const worktreeResult = await createWorktreeWithSubmodules({
     clientV2,
     directory: projectDirectory,
     name: worktreeName,
+    diff,
   })
 
   if (worktreeResult instanceof Error) {
@@ -123,10 +127,12 @@ async function createWorktreeInBackground({
 
   // Success - update database and edit starter message
   setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory })
+  const diffStatus = diff ? (worktreeResult.diffApplied ? '\n✅ Changes applied' : '\n⚠️ Failed to apply changes') : ''
   await starterMessage.edit(
     `🌳 **Worktree: ${worktreeName}**\n` +
     `📁 \`${worktreeResult.directory}\`\n` +
-    `🌿 Branch: \`${worktreeResult.branch}\``
+    `🌿 Branch: \`${worktreeResult.branch}\`` +
+    diffStatus
   )
 }
 
@@ -337,6 +343,11 @@ async function handleWorktreeInThread({
     return
   }
 
+  // Capture git diff from project directory before creating worktree.
+  // This allows transferring uncommitted changes to the new worktree.
+  const diff = await captureGitDiff(projectDirectory)
+  const hasDiff = diff && (diff.staged || diff.unstaged)
+
   // Store pending worktree in database for this existing thread
   createPendingWorktree({
     threadId: thread.id,
@@ -345,20 +356,22 @@ async function handleWorktreeInThread({
   })
 
   // Send status message in thread
+  const diffNote = hasDiff ? '\n📋 Will transfer uncommitted changes' : ''
   const statusMessage = await thread.send({
-    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...${diffNote}`,
     flags: SILENT_MESSAGE_FLAGS,
   })
 
   await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`)
 
-  // Create worktree in background
+  // Create worktree in background, passing diff to apply after creation
   createWorktreeInBackground({
     thread,
     starterMessage: statusMessage,
     worktreeName,
     projectDirectory,
     clientV2,
+    diff,
   }).catch((e) => {
     logger.error('[NEW-WORKTREE] Background error:', e)
   })