kimaki 0.4.45 → 0.4.47

package/dist/cli.js

@@ -10,13 +10,33 @@ import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuild
 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 } 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';
 async function killProcessOnPort(port) {
@@ -217,6 +237,10 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .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')
@@ -389,6 +413,7 @@ async function backgroundInit({ currentDir, token, appId, }) {
     }
 }
 async function run({ restart, addChannels, useWorktrees }) {
+    startCaffeinate();
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
     // Step 0: Check if OpenCode CLI is available

package/dist/commands/abort.js

@@ -4,9 +4,9 @@ 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 }) {
     const channel = command.channel;
     if (!channel) {

package/dist/commands/add-project.js

@@ -4,10 +4,10 @@ import path from 'node:path';
 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 }) {
     await command.deferReply({ ephemeral: false });
     const projectId = command.options.getString('project', true);

package/dist/commands/agent.js

@@ -5,9 +5,9 @@ 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();
 /**
  * Sanitize an agent name to be a valid Discord command name component.
@@ -181,7 +181,7 @@ export async function handleAgentSelectMenu(interaction) {
         }
         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: [],
             });
         }
@@ -237,7 +237,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
         }
         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.`,
             });
         }
     }

package/dist/commands/ask-question.js

@@ -5,8 +5,8 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
 import { getOpencodeClientV2 } from '../opencode.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('ASK_QUESTION');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.ASK_QUESTION);
 // Store pending question contexts by hash
 export const pendingQuestionContexts = new Map();
 /**
@@ -178,9 +178,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) {
+export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
     let contextHash;
     let context;
@@ -199,18 +199,19 @@ export async function cancelPendingQuestion(threadId) {
         if (!clientV2) {
             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({
             requestID: context.requestId,
             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
     pendingQuestionContexts.delete(contextHash);

package/dist/commands/compact.js

@@ -0,0 +1,126 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+import { ChannelType } from 'discord.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 }) {
+    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);
+    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);
+    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.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/dist/commands/create-new-project.js

@@ -6,8 +6,8 @@ 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';
-const logger = createLogger('CREATE-NEW-PROJECT');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.CREATE_PROJECT);
 export async function handleCreateNewProjectCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
     const projectName = command.options.getString('name', true);
@@ -53,7 +53,7 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
             appId,
         });
         const textChannel = (await guild.channels.fetch(textChannelId));
-        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`);
         const starterMessage = await textChannel.send({
             content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
             flags: SILENT_MESSAGE_FLAGS,
@@ -63,6 +63,8 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
             autoArchiveDuration: 1440,
             reason: 'New project session',
         });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
         await handleOpencodeSession({
             prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
             thread,

package/dist/commands/fork.js

@@ -4,10 +4,10 @@ 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) {
     const channel = interaction.channel;
     if (!channel) {
@@ -162,6 +162,8 @@ export async function handleForkSelectMenu(interaction) {
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `Forked from session ${sessionId}`,
         });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(interaction.user.id);
         getDatabase()
             .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
             .run(thread.id, forkedSession.id);

package/dist/commands/merge-worktree.js

@@ -3,9 +3,9 @@
 // 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 { 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/dist/commands/model.js

@@ -5,9 +5,9 @@ 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();
 /**
@@ -292,13 +292,13 @@ export async function handleModelSelectMenu(interaction) {
             }
             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: [],
                 });
             }
@@ -308,7 +308,7 @@ export async function handleModelSelectMenu(interaction) {
             setChannelModel(context.channelId, fullModelId);
             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/dist/commands/permissions.js

@@ -5,8 +5,8 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { getOpencodeClientV2 } from '../opencode.js';
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('PERMISSIONS');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.PERMISSIONS);
 // Store pending permission contexts by hash
 export const pendingPermissionContexts = new Map();
 /**

package/dist/commands/queue.js

@@ -3,8 +3,8 @@ import { ChannelType } from 'discord.js';
 import { getDatabase } from '../database.js';
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { handleOpencodeSession, abortControllers, addToQueue, getQueueLength, clearQueue, } from '../session-handler.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('QUEUE');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.QUEUE);
 export async function handleQueueCommand({ command }) {
     const message = command.options.getString('message', true);
     const channel = command.channel;

package/dist/commands/remove-project.js

@@ -2,9 +2,9 @@
 import path from 'node:path';
 import * as errore from 'errore';
 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 }) {
     await command.deferReply({ ephemeral: false });
     const directory = command.options.getString('project', true);

package/dist/commands/resume.js

@@ -5,9 +5,9 @@ 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 }) {
     await command.deferReply({ ephemeral: false });
     const sessionId = command.options.getString('session', true);
@@ -51,6 +51,8 @@ export async function handleResumeCommand({ command, appId }) {
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `Resuming session ${sessionId}`,
         });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
         getDatabase()
             .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
             .run(thread.id, sessionId);

package/dist/commands/session.js

@@ -6,9 +6,9 @@ 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 }) {
     await command.deferReply({ ephemeral: false });
     const prompt = command.options.getString('prompt', true);
@@ -58,6 +58,8 @@ export async function handleSessionCommand({ command, appId }) {
             autoArchiveDuration: 1440,
             reason: 'OpenCode session',
         });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
         await command.editReply(`Created new session in ${thread.toString()}`);
         await handleOpencodeSession({
             prompt: fullPrompt,

package/dist/commands/share.js

@@ -3,9 +3,9 @@ import { ChannelType } from 'discord.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 }) {
     const channel = command.channel;
     if (!channel) {

package/dist/commands/undo-redo.js

@@ -3,9 +3,9 @@ import { ChannelType } from 'discord.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 }) {
     const channel = command.channel;
     if (!channel) {

package/dist/commands/user-command.js

@@ -3,10 +3,10 @@
 import { ChannelType } 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 = async ({ command, appId }) => {
     const discordCommandName = command.commandName;
     // Strip the -cmd suffix to get the actual OpenCode command name
@@ -105,6 +105,8 @@ export const handleUserCommand = async ({ command, appId }) => {
                 autoArchiveDuration: 1440,
                 reason: `OpenCode command: ${commandName}`,
             });
+            // Add user to thread so it appears in their sidebar
+            await newThread.members.add(command.user.id);
             await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
             await handleOpencodeSession({
                 prompt: '', // Not used when command is set

package/dist/commands/verbosity.js

@@ -4,8 +4,8 @@
 // 'text-only': only shows text responses (⬥ diamond parts)
 import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
 import { getChannelVerbosity, setChannelVerbosity } from '../database.js';
-import { createLogger } from '../logger.js';
-const verbosityLogger = createLogger('VERBOSITY');
+import { createLogger, LogPrefix } from '../logger.js';
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
 /**
  * Handle the /verbosity slash command.
  * Sets output verbosity for the channel (applies to new sessions).
@@ -47,7 +47,7 @@ export async function handleVerbosityCommand({ command, appId, }) {
         ? 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
         : '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/dist/commands/worktree-settings.js

@@ -4,8 +4,8 @@
 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');
+import { createLogger, LogPrefix } from '../logger.js';
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE);
 /**
  * Handle the /enable-worktrees slash command.
  * Enables automatic worktree creation for new sessions in this channel.

package/dist/commands/worktree.js

@@ -6,11 +6,11 @@ import fs from 'node:fs';
 import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } 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 } 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, options) {
         super(message, options);
@@ -69,14 +69,16 @@ function getProjectDirectoryFromChannel(channel, appId) {
 }
 /**
  * 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, starterMessage, worktreeName, projectDirectory, clientV2, }) {
-    // Create worktree using SDK v2 and init submodules
+async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, diff, }) {
+    // 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) {
         const errorMsg = worktreeResult.message;
@@ -87,9 +89,11 @@ async function createWorktreeInBackground({ thread, starterMessage, worktreeName
     }
     // 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);
 }
 export async function handleNewWorktreeCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
@@ -167,6 +171,8 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
                 autoArchiveDuration: 1440,
                 reason: 'Worktree session',
             });
+            // Add user to thread so it appears in their sidebar
+            await thread.members.add(command.user.id);
             return { thread, starterMessage };
         },
         catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
@@ -251,6 +257,10 @@ async function handleWorktreeInThread({ command, appId, thread, }) {
         await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
         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,
@@ -258,18 +268,20 @@ async function handleWorktreeInThread({ command, appId, thread, }) {
         projectDirectory,
     });
     // 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);
     });