kimaki 0.4.45 → 0.4.47

package/dist/worktree-utils.js

@@ -1,15 +1,19 @@
 // Worktree utility functions.
 // Wrapper for OpenCode worktree creation that also initializes git submodules.
-import { exec } from 'node:child_process';
+// Also handles capturing and applying git diffs when creating worktrees from threads.
+import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 export const execAsync = promisify(exec);
-const logger = createLogger('WORKTREE-UTILS');
+const logger = createLogger(LogPrefix.WORKTREE);
 /**
  * Create a worktree using OpenCode SDK and initialize git submodules.
  * This wrapper ensures submodules are properly set up in new worktrees.
+ *
+ * If diff is provided, it's applied BEFORE submodule update to ensure
+ * any submodule pointer changes in the diff are respected.
  */
-export async function createWorktreeWithSubmodules({ clientV2, directory, name, }) {
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, diff, }) {
     // 1. Create worktree via OpenCode SDK
     const response = await clientV2.worktree.create({
         directory,
@@ -22,7 +26,17 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         return new Error('No worktree data returned from SDK');
     }
     const worktreeDir = response.data.directory;
-    // 2. Init submodules in new worktree (don't block on failure)
+    let diffApplied = false;
+    // 2. Apply diff BEFORE submodule update (if provided)
+    // This ensures any submodule pointer changes in the diff are applied first,
+    // so submodule update checks out the correct commits.
+    if (diff) {
+        logger.log(`Applying diff to ${worktreeDir} before submodule init`);
+        diffApplied = await applyGitDiff(worktreeDir, diff);
+    }
+    // 3. Init submodules in new worktree (don't block on failure)
+    // Uses --init to initialize, --recursive for nested submodules.
+    // Submodules will be checked out at the commit specified by the (possibly updated) index.
     try {
         logger.log(`Initializing submodules in ${worktreeDir}`);
         await execAsync('git submodule update --init --recursive', {
@@ -34,7 +48,7 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - submodules might not exist
         logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    // 3. Install dependencies using ni (detects package manager from lockfile)
+    // 4. Install dependencies using ni (detects package manager from lockfile)
     try {
         logger.log(`Installing dependencies in ${worktreeDir}`);
         await execAsync('npx -y ni', {
@@ -46,5 +60,75 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - might not be a JS project or might fail for various reasons
         logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return response.data;
+    return { ...response.data, diffApplied };
+}
+/**
+ * Capture git diff from a directory (both staged and unstaged changes).
+ * Returns null if no changes or on error.
+ */
+export async function captureGitDiff(directory) {
+    try {
+        // Capture unstaged changes
+        const unstagedResult = await execAsync('git diff', { cwd: directory });
+        const unstaged = unstagedResult.stdout.trim();
+        // Capture staged changes
+        const stagedResult = await execAsync('git diff --staged', { cwd: directory });
+        const staged = stagedResult.stdout.trim();
+        if (!unstaged && !staged) {
+            return null;
+        }
+        return { unstaged, staged };
+    }
+    catch (e) {
+        logger.warn(`Failed to capture git diff from ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+/**
+ * Run a git command with stdin input.
+ * Uses spawn to pipe the diff content to git apply.
+ */
+function runGitWithStdin(args, cwd, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr || `git ${args.join(' ')} failed with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
+/**
+ * Apply a captured git diff to a directory.
+ * Applies staged changes first, then unstaged.
+ */
+export async function applyGitDiff(directory, diff) {
+    try {
+        // Apply staged changes first (and stage them)
+        if (diff.staged) {
+            logger.log(`Applying staged diff to ${directory}`);
+            await runGitWithStdin(['apply', '--index'], directory, diff.staged);
+        }
+        // Apply unstaged changes (don't stage them)
+        if (diff.unstaged) {
+            logger.log(`Applying unstaged diff to ${directory}`);
+            await runGitWithStdin(['apply'], directory, diff.unstaged);
+        }
+        logger.log(`Successfully applied diff to ${directory}`);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`Failed to apply git diff to ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
 }

package/dist/xml.js

@@ -2,8 +2,8 @@
 // Parses XML-like tags from strings (e.g., channel topics) to extract
 // Kimaki configuration like directory paths and app IDs.
 import { DomHandler, Parser, ElementType } from 'htmlparser2';
-import { createLogger } from './logger.js';
-const xmlLogger = createLogger('XML');
+import { createLogger, LogPrefix } from './logger.js';
+const xmlLogger = createLogger(LogPrefix.XML);
 export function extractTagsArrays({ xml, tags, }) {
     const result = {
         others: [],

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.45",
+  "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({
@@ -88,6 +88,9 @@ export async function handleCreateNewProjectCommand({
       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/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
@@ -215,6 +215,9 @@ export async function handleForkSelectMenu(
       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/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 })
@@ -73,6 +73,9 @@ export async function handleResumeCommand({ command, appId }: CommandContext): P
       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/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 })
@@ -75,6 +75,9 @@ export async function handleSessionCommand({ command, appId }: CommandContext):
       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({