kimaki 0.4.46 → 0.4.48

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

@@ -1,16 +1,79 @@
 // /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
 
-import { ChannelType, type TextChannel } from 'discord.js'
+import { ChannelType, type Guild, type TextChannel } from 'discord.js'
 import fs from 'node:fs'
 import path from 'node:path'
+import { execSync } from 'node:child_process'
 import type { CommandContext } from './types.js'
 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(LogPrefix.CREATE_PROJECT)
+
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({
+  guild,
+  projectName,
+  appId,
+  botName,
+}: {
+  guild: Guild
+  projectName: string
+  appId: string
+  botName?: string
+}): Promise<{
+  textChannelId: string
+  voiceChannelId: string
+  channelName: string
+  projectDirectory: string
+  sanitizedName: string
+} | null> {
+  const sanitizedName = projectName
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 100)
+
+  if (!sanitizedName) {
+    return null
+  }
 
-const logger = createLogger('CREATE-NEW-PROJECT')
+  const projectsDir = getProjectsDir()
+  const projectDirectory = path.join(projectsDir, sanitizedName)
+
+  if (!fs.existsSync(projectsDir)) {
+    fs.mkdirSync(projectsDir, { recursive: true })
+    logger.log(`Created projects directory: ${projectsDir}`)
+  }
+
+  if (fs.existsSync(projectDirectory)) {
+    return null
+  }
+
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  logger.log(`Created project directory: ${projectDirectory}`)
+
+  execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
+  logger.log(`Initialized git in: ${projectDirectory}`)
+
+  const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+    guild,
+    projectDirectory,
+    appId,
+    botName,
+  })
+
+  return { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName }
+}
 
 export async function handleCreateNewProjectCommand({
   command,
@@ -32,49 +95,37 @@ export async function handleCreateNewProjectCommand({
     return
   }
 
-  const sanitizedName = projectName
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-    .slice(0, 100)
-
-  if (!sanitizedName) {
-    await command.editReply('Invalid project name')
-    return
-  }
+  try {
+    const result = await createNewProject({
+      guild,
+      projectName,
+      appId,
+      botName: command.client.user?.username,
+    })
 
-  const projectsDir = getProjectsDir()
-  const projectDirectory = path.join(projectsDir, sanitizedName)
+    if (!result) {
+      const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100)
 
-  try {
-    if (!fs.existsSync(projectsDir)) {
-      fs.mkdirSync(projectsDir, { recursive: true })
-      logger.log(`Created projects directory: ${projectsDir}`)
-    }
+      if (!sanitizedName) {
+        await command.editReply('Invalid project name')
+        return
+      }
 
-    if (fs.existsSync(projectDirectory)) {
+      const projectDirectory = path.join(getProjectsDir(), sanitizedName)
       await command.editReply(`Project directory already exists: ${projectDirectory}`)
       return
     }
 
-    fs.mkdirSync(projectDirectory, { recursive: true })
-    logger.log(`Created project directory: ${projectDirectory}`)
-
-    const { execSync } = await import('node:child_process')
-    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
-    logger.log(`Initialized git in: ${projectDirectory}`)
-
-    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
-      guild,
-      projectDirectory,
-      appId,
-    })
-
+    const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result
     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 = '⬦ '
@@ -47,7 +47,11 @@ async function isDetachedHead(worktreeDir: string): Promise<boolean> {
   try {
     await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`)
     return false
-  } catch {
+  } catch (error) {
+    logger.debug(
+      `Failed to resolve HEAD for ${worktreeDir}:`,
+      error instanceof Error ? error.message : String(error),
+    )
     return true
   }
 }
@@ -59,7 +63,11 @@ async function getCurrentBranch(worktreeDir: string): Promise<string | null> {
   try {
     const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`)
     return stdout.trim() || null
-  } catch {
+  } catch (error) {
+    logger.debug(
+      `Failed to get current branch for ${worktreeDir}:`,
+      error instanceof Error ? error.message : String(error),
+    )
     return null
   }
 }
@@ -113,7 +121,11 @@ export async function handleMergeWorktreeCommand({ command, appId }: CommandCont
         `git -C "${mainRepoDir}" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`,
       )
       defaultBranch = stdout.trim() || 'main'
-    } catch {
+    } catch (error) {
+      logger.warn(
+        `Failed to detect default branch for ${mainRepoDir}, falling back to main:`,
+        error instanceof Error ? error.message : String(error),
+      )
       defaultBranch = 'main'
     }
 
@@ -141,11 +153,26 @@ export async function handleMergeWorktreeCommand({ command, appId }: CommandCont
       await execAsync(`git -C "${worktreeDir}" merge ${defaultBranch} --no-edit`)
     } catch (e) {
       // If merge fails (conflicts), abort and report
-      await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => {})
+      await execAsync(`git -C "${worktreeDir}" merge --abort`).catch((error) => {
+        logger.warn(
+          `Failed to abort merge in ${worktreeDir}:`,
+          error instanceof Error ? error.message : String(error),
+        )
+      })
       // Clean up temp branch if we created one
       if (tempBranch) {
-        await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch(() => {})
-        await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch(() => {})
+        await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch((error) => {
+          logger.warn(
+            `Failed to detach HEAD after merge conflict in ${worktreeDir}:`,
+            error instanceof Error ? error.message : String(error),
+          )
+        })
+        await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch((error) => {
+          logger.warn(
+            `Failed to delete temp branch ${tempBranch} in ${worktreeDir}:`,
+            error instanceof Error ? error.message : String(error),
+          )
+        })
       }
       throw new Error(`Merge conflict - resolve manually in worktree then retry`)
     }
@@ -162,11 +189,21 @@ export async function handleMergeWorktreeCommand({ command, appId }: CommandCont
 
     // 7. Delete the merged branch (temp or original)
     logger.log(`Deleting merged branch ${branchToMerge}`)
-    await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch(() => {})
+    await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch((error) => {
+      logger.warn(
+        `Failed to delete merged branch ${branchToMerge} in ${worktreeDir}:`,
+        error instanceof Error ? error.message : String(error),
+      )
+    })
 
     // Also delete the original worktree branch if different from what we merged
     if (!isDetached && branchToMerge !== worktreeInfo.worktree_name) {
-      await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch(() => {})
+      await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch((error) => {
+        logger.warn(
+          `Failed to delete worktree branch ${worktreeInfo.worktree_name} in ${worktreeDir}:`,
+          error instanceof Error ? error.message : String(error),
+        )
+      })
     }
 
     // 8. Remove worktree prefix from thread title (fire and forget with timeout)

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
@@ -35,10 +35,12 @@ export async function showPermissionDropdown({
   thread,
   permission,
   directory,
+  subtaskLabel,
 }: {
   thread: ThreadChannel
   permission: PermissionRequest
   directory: string
+  subtaskLabel?: string
 }): Promise<{ messageId: string; contextHash: string }> {
   const contextHash = crypto.randomBytes(8).toString('hex')
 
@@ -80,9 +82,11 @@ export async function showPermissionDropdown({
 
   const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
 
+  const subtaskLine = subtaskLabel ? `**From:** \`${subtaskLabel}\`\n` : ''
   const permissionMessage = await thread.send({
     content:
       `⚠️ **Permission Required**\n\n` +
+      subtaskLine +
       `**Type:** \`${permission.permission}\`\n` +
       (patternStr ? `**Pattern:** \`${patternStr}\`` : ''),
     components: [actionRow],

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 })
@@ -133,7 +133,10 @@ async function handleAgentAutocomplete({ interaction, appId }: AutocompleteConte
     }
 
     const agents = agentsResponse.data
-      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .filter((a) => {
+        const hidden = (a as { hidden?: boolean }).hidden
+        return (a.mode === 'primary' || a.mode === 'all') && !hidden
+      })
       .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
       .slice(0, 25)
 

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,13 +5,13 @@
 
 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.
- * Sets output verbosity for the channel (applies to new sessions).
+ * Sets output verbosity for the channel (applies immediately, even mid-session).
  */
 export async function handleVerbosityCommand({
   command,
@@ -51,7 +51,7 @@ export async function handleVerbosityCommand({
 
   if (currentLevel === level) {
     await command.reply({
-      content: `Verbosity is already set to **${level}**.`,
+      content: `Verbosity is already set to **${level}** for this channel.`,
       ephemeral: true,
     })
     return
@@ -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}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
     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.