kimaki 0.4.36 → 0.4.38

package/dist/session-handler.js

@@ -473,6 +473,30 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         requestId: questionRequest.id,
                         input: { questions: questionRequest.questions },
                     });
+                    // Process queued messages if any - queued message will cancel the pending question
+                    const queue = messageQueue.get(thread.id);
+                    if (queue && queue.length > 0) {
+                        const nextMessage = queue.shift();
+                        if (queue.length === 0) {
+                            messageQueue.delete(thread.id);
+                        }
+                        sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
+                        await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+                        // handleOpencodeSession will call cancelPendingQuestion, which cancels the dropdown
+                        setImmediate(() => {
+                            handleOpencodeSession({
+                                prompt: nextMessage.prompt,
+                                thread,
+                                projectDirectory: directory,
+                                images: nextMessage.images,
+                                channelId,
+                            }).catch(async (e) => {
+                                sessionLogger.error(`[QUEUE] Failed to process queued message:`, e);
+                                const errorMsg = e instanceof Error ? e.message : String(e);
+                                await sendThreadMessage(thread, `✗ Queued message failed: ${errorMsg.slice(0, 200)}`);
+                            });
+                        });
+                    }
                 }
                 else if (event.type === 'session.idle') {
                     // Session is done processing - abort to signal completion
@@ -581,9 +605,20 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         })();
         const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
         sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+        // Get agent preference: session-level overrides channel-level
+        const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined);
+        if (agentPreference) {
+            sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
+        }
         // Get model preference: session-level overrides channel-level
+        // BUT: if an agent is set, don't pass model param so the agent's model takes effect
         const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
         const modelParam = (() => {
+            // When an agent is set, let the agent's model config take effect
+            if (agentPreference) {
+                sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`);
+                return undefined;
+            }
             if (!modelPreference) {
                 return undefined;
             }
@@ -595,11 +630,6 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
             return { providerID, modelID };
         })();
-        // Get agent preference: session-level overrides channel-level
-        const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined);
-        if (agentPreference) {
-            sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
-        }
         // Use session.command API for slash commands, session.prompt for regular messages
         const response = command
             ? await getClient().session.command({
@@ -650,8 +680,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return { sessionID: session.id, result: response.data, port };
     }
     catch (error) {
-        sessionLogger.error(`ERROR: Failed to send prompt:`, error);
         if (!isAbortError(error, abortController.signal)) {
+            sessionLogger.error(`ERROR: Failed to send prompt:`, error);
             abortController.abort('error');
             if (originalMessage) {
                 try {

package/dist/system-message.js

@@ -28,7 +28,11 @@ ${channelId
 
 To start a new thread/session in this channel programmatically, run:
 
-npx -y kimaki start-session --channel ${channelId} --prompt "your prompt here"
+npx -y kimaki send --channel ${channelId} --prompt "your prompt here"
+
+Use --notify-only to create a notification thread without starting an AI session:
+
+npx -y kimaki send --channel ${channelId} --prompt "User cancelled subscription" --notify-only
 
 This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
 `

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.36",
+  "version": "0.4.38",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

package/src/channel-management.ts

@@ -11,7 +11,9 @@ export async function ensureKimakiCategory(
   guild: Guild,
   botName?: string,
 ): Promise<CategoryChannel> {
-  const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki'
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki'
 
   const existingCategory = guild.channels.cache.find((channel): channel is CategoryChannel => {
     if (channel.type !== ChannelType.GuildCategory) {
@@ -35,7 +37,9 @@ export async function ensureKimakiAudioCategory(
   guild: Guild,
   botName?: string,
 ): Promise<CategoryChannel> {
-  const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
 
   const existingCategory = guild.channels.cache.find((channel): channel is CategoryChannel => {
     if (channel.type !== ChannelType.GuildCategory) {
@@ -90,15 +94,15 @@ export async function createProjectChannels({
 
   getDatabase()
     .prepare(
-      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
     )
-    .run(textChannel.id, projectDirectory, 'text')
+    .run(textChannel.id, projectDirectory, 'text', appId)
 
   getDatabase()
     .prepare(
-      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
     )
-    .run(voiceChannel.id, projectDirectory, 'voice')
+    .run(voiceChannel.id, projectDirectory, 'voice', appId)
 
   return {
     textChannelId: textChannel.id,

package/src/cli.ts

@@ -46,6 +46,7 @@ import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_pro
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
 import { extractTagsArrays } from './xml.js'
+import { sanitizeAgentName } from './commands/agent.js'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
@@ -176,11 +177,23 @@ type CliOptions = {
 // Commands to skip when registering user commands (reserved names)
 const SKIP_USER_COMMANDS = ['init']
 
-async function registerCommands(
-  token: string,
-  appId: string,
-  userCommands: OpencodeCommand[] = [],
-) {
+type AgentInfo = {
+  name: string
+  description?: string
+  mode: string
+}
+
+async function registerCommands({
+  token,
+  appId,
+  userCommands = [],
+  agents = [],
+}: {
+  token: string
+  appId: string
+  userCommands?: OpencodeCommand[]
+  agents?: AgentInfo[]
+}) {
   const commands = [
     new SlashCommandBuilder()
       .setName('resume')
@@ -329,6 +342,22 @@ async function registerCommands(
     )
   }
 
+  // Add agent-specific quick commands like /plan-agent, /build-agent
+  // Filter to primary/all mode agents (same as /agent command shows)
+  const primaryAgents = agents.filter((a) => a.mode === 'primary' || a.mode === 'all')
+  for (const agent of primaryAgents) {
+    const sanitizedName = sanitizeAgentName(agent.name)
+    const commandName = `${sanitizedName}-agent`
+    const description = agent.description || `Switch to ${agent.name} agent`
+
+    commands.push(
+      new SlashCommandBuilder()
+        .setName(commandName.slice(0, 32)) // Discord limits to 32 chars
+        .setDescription(description.slice(0, 100))
+        .toJSON(),
+    )
+  }
+
   const rest = new REST().setToken(token)
 
   try {
@@ -632,8 +661,8 @@ async function run({ restart, addChannels }: CliOptions) {
     for (const channel of channels) {
       if (channel.kimakiDirectory) {
         db.prepare(
-          'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-        ).run(channel.id, channel.kimakiDirectory, 'text')
+          'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
+        ).run(channel.id, channel.kimakiDirectory, 'text', channel.kimakiApp || null)
 
         const voiceChannel = guild.channels.cache.find(
           (ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name,
@@ -641,8 +670,8 @@ async function run({ restart, addChannels }: CliOptions) {
 
         if (voiceChannel) {
           db.prepare(
-            'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-          ).run(voiceChannel.id, channel.kimakiDirectory, 'voice')
+            'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
+          ).run(voiceChannel.id, channel.kimakiDirectory, 'voice', channel.kimakiApp || null)
         }
       }
     }
@@ -669,8 +698,8 @@ async function run({ restart, addChannels }: CliOptions) {
 
   s.start('Fetching OpenCode data...')
 
-  // Fetch projects and commands in parallel
-  const [projects, allUserCommands] = await Promise.all([
+  // Fetch projects, commands, and agents in parallel
+  const [projects, allUserCommands, allAgents] = await Promise.all([
     getClient()
       .project.list({})
       .then((r) => r.data || [])
@@ -684,6 +713,10 @@ async function run({ restart, addChannels }: CliOptions) {
       .command.list({ query: { directory: currentDir } })
       .then((r) => r.data || [])
       .catch(() => []),
+    getClient()
+      .app.agents({ query: { directory: currentDir } })
+      .then((r) => r.data || [])
+      .catch(() => []),
   ])
 
   s.stop(`Found ${projects.length} OpenCode project(s)`)
@@ -805,7 +838,7 @@ async function run({ restart, addChannels }: CliOptions) {
   }
 
   cliLogger.log('Registering slash commands asynchronously...')
-  void registerCommands(token, appId, allUserCommands)
+  void registerCommands({ token, appId, userCommands: allUserCommands, agents: allAgents })
     .then(() => {
       cliLogger.log('Slash commands registered!')
     })
@@ -999,20 +1032,20 @@ cli
     }
   })
 
-// Magic prefix used to identify bot-initiated sessions.
-// The running bot will recognize this prefix and start a session.
-const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
+
 
 cli
   .command(
-    'start-session',
-    'Start a new session in a Discord channel (creates thread, bot handles the rest)',
+    'send',
+    'Send a message to Discord channel, creating a thread. Use --notify-only to skip AI session.',
   )
+  .alias('start-session') // backwards compatibility
   .option('-c, --channel <channelId>', 'Discord channel ID')
   .option('-d, --project <path>', 'Project directory (alternative to --channel)')
-  .option('-p, --prompt <prompt>', 'Initial prompt for the session')
+  .option('-p, --prompt <prompt>', 'Message content')
   .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
   .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
+  .option('--notify-only', 'Create notification thread without starting AI session')
   .action(
     async (options: {
       channel?: string
@@ -1020,10 +1053,20 @@ cli
       prompt?: string
       name?: string
       appId?: string
+      notifyOnly?: boolean
     }) => {
       try {
-        let { channel: channelId, prompt, name, appId: optionAppId } = options
+        let { channel: channelId, prompt, name, appId: optionAppId, notifyOnly } = options
         const { project: projectPath } = options
+        
+        // Get raw channel ID from argv to prevent JS number precision loss on large Discord IDs
+        // cac parses large numbers and loses precision, so we extract the original string value
+        if (channelId) {
+          const channelArgIndex = process.argv.findIndex((arg) => arg === '--channel' || arg === '-c')
+          if (channelArgIndex !== -1 && process.argv[channelArgIndex + 1]) {
+            channelId = process.argv[channelArgIndex + 1]
+          }
+        }
 
         if (!channelId && !projectPath) {
           cliLogger.error('Either --channel or --project is required')
@@ -1092,18 +1135,43 @@ cli
 
         s.start('Looking up channel for project...')
 
-        // Check if channel already exists for this directory
+        // Check if channel already exists for this directory or a parent directory
+        // This allows running from subfolders of a registered project
         try {
           const db = getDatabase()
-          const existingChannel = db
-            .prepare(
-              'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
-            )
-            .get(absolutePath, 'text') as { channel_id: string } | undefined
+          
+          // Helper to find channel for a path (prefers current bot's channel)
+          const findChannelForPath = (dirPath: string): { channel_id: string; directory: string } | undefined => {
+            const withAppId = db
+              .prepare(
+                'SELECT channel_id, directory FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?',
+              )
+              .get(dirPath, 'text', appId) as { channel_id: string; directory: string } | undefined
+            if (withAppId) return withAppId
+            
+            return db
+              .prepare(
+                'SELECT channel_id, directory FROM channel_directories WHERE directory = ? AND channel_type = ?',
+              )
+              .get(dirPath, 'text') as { channel_id: string; directory: string } | undefined
+          }
+          
+          // Try exact match first, then walk up parent directories
+          let existingChannel: { channel_id: string; directory: string } | undefined
+          let searchPath = absolutePath
+          while (searchPath !== path.dirname(searchPath)) {
+            existingChannel = findChannelForPath(searchPath)
+            if (existingChannel) break
+            searchPath = path.dirname(searchPath)
+          }
 
           if (existingChannel) {
             channelId = existingChannel.channel_id
-            s.message(`Found existing channel: ${channelId}`)
+            if (existingChannel.directory !== absolutePath) {
+              s.message(`Found parent project channel: ${existingChannel.directory}`)
+            } else {
+              s.message(`Found existing channel: ${channelId}`)
+            }
           } else {
             // Need to create a new channel
             s.message('Creating new channel...')
@@ -1128,12 +1196,12 @@ cli
 
             // Get guild from existing channels or first available
             const guild = await (async () => {
-              // Try to find a guild from existing channels
+              // Try to find a guild from existing channels belonging to this bot
               const existingChannelRow = db
                 .prepare(
-                  'SELECT channel_id FROM channel_directories ORDER BY created_at DESC LIMIT 1',
+                  'SELECT channel_id FROM channel_directories WHERE app_id = ? ORDER BY created_at DESC LIMIT 1',
                 )
-                .get() as { channel_id: string } | undefined
+                .get(appId) as { channel_id: string } | undefined
 
               if (existingChannelRow) {
                 try {
@@ -1145,7 +1213,7 @@ cli
                   // Channel might be deleted, continue
                 }
               }
-              // Fall back to first guild
+              // Fall back to first guild the bot is in
               const firstGuild = client.guilds.cache.first()
               if (!firstGuild) {
                 throw new Error('No guild found. Add the bot to a server first.')
@@ -1223,8 +1291,7 @@ cli
 
       s.message('Creating starter message...')
 
-      // Create starter message with magic prefix
-      // The full prompt goes in the message so the bot can read it
+      // Create starter message with just the prompt (no prefix)
       const starterMessageResponse = await fetch(
         `https://discord.com/api/v10/channels/${channelId}/messages`,
         {
@@ -1234,7 +1301,7 @@ cli
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
-            content: `${BOT_SESSION_PREFIX}\n${prompt}`,
+            content: prompt,
           }),
         },
       )
@@ -1274,14 +1341,28 @@ cli
 
       const threadData = (await threadResponse.json()) as { id: string; name: string }
 
+      // Mark thread for auto-start if not notify-only
+      // This is optional - only works if local database exists (for local bot auto-start)
+      if (!notifyOnly) {
+        try {
+          const db = getDatabase()
+          db.prepare('INSERT OR REPLACE INTO pending_auto_start (thread_id) VALUES (?)').run(
+            threadData.id,
+          )
+        } catch {
+          // Database not available (e.g., CI environment) - skip auto-start marking
+        }
+      }
+
       s.stop('Thread created!')
 
       const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`
 
-      note(
-        `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`,
-        '✅ Thread Created',
-      )
+      const successMessage = notifyOnly
+        ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
+        : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`
+
+      note(successMessage, '✅ Thread Created')
 
       console.log(threadUrl)
 

package/src/commands/agent.ts

@@ -1,4 +1,5 @@
 // /agent command - Set the preferred agent for this channel or session.
+// Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
 
 import {
   ChatInputCommandInteraction,
@@ -10,7 +11,7 @@ import {
   type TextChannel,
 } from 'discord.js'
 import crypto from 'node:crypto'
-import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js'
+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'
@@ -27,22 +28,40 @@ const pendingAgentContexts = new Map<
   }
 >()
 
-export async function handleAgentCommand({
+/**
+ * Context for agent commands, containing channel/session info.
+ */
+export type AgentCommandContext = {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}
+
+/**
+ * Sanitize an agent name to be a valid Discord command name component.
+ * Lowercase, alphanumeric and hyphens only.
+ */
+export function sanitizeAgentName(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+}
+
+/**
+ * Resolve the context for an agent command (directory, channel, session).
+ * Returns null if the command cannot be executed in this context.
+ */
+export async function resolveAgentCommandContext({
   interaction,
   appId,
 }: {
   interaction: ChatInputCommandInteraction
   appId: string
-}): Promise<void> {
-  await interaction.deferReply({ ephemeral: true })
-
-  runModelMigrations()
-
+}): Promise<AgentCommandContext | null> {
   const channel = interaction.channel
 
   if (!channel) {
     await interaction.editReply({ content: 'This command can only be used in a channel' })
-    return
+    return null
   }
 
   const isThread = [
@@ -78,26 +97,73 @@ export async function handleAgentCommand({
     await interaction.editReply({
       content: 'This command can only be used in text channels or threads',
     })
-    return
+    return null
   }
 
   if (channelAppId && channelAppId !== appId) {
     await interaction.editReply({ content: 'This channel is not configured for this bot' })
-    return
+    return null
   }
 
   if (!projectDirectory) {
     await interaction.editReply({
       content: 'This channel is not configured with a project directory',
     })
+    return null
+  }
+
+  return {
+    dir: projectDirectory,
+    channelId: targetChannelId,
+    sessionId,
+    isThread,
+  }
+}
+
+/**
+ * Set the agent preference for a context (session or channel).
+ * When switching agents for a session, also clears the session model preference
+ * so the new agent's model takes effect.
+ */
+export function setAgentForContext({
+  context,
+  agentName,
+}: {
+  context: AgentCommandContext
+  agentName: string
+}): void {
+  if (context.isThread && context.sessionId) {
+    setSessionAgent(context.sessionId, agentName)
+    // Clear session model so the new agent's model takes effect
+    clearSessionModel(context.sessionId)
+    agentLogger.log(`Set agent ${agentName} for session ${context.sessionId} (cleared model preference)`)
+  } else {
+    setChannelAgent(context.channelId, agentName)
+    agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`)
+  }
+}
+
+export async function handleAgentCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await interaction.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  const context = await resolveAgentCommandContext({ interaction, appId })
+  if (!context) {
     return
   }
 
   try {
-    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    const getClient = await initializeOpencodeForDirectory(context.dir)
 
     const agentsResponse = await getClient().app.agents({
-      query: { directory: projectDirectory },
+      query: { directory: context.dir },
     })
 
     if (!agentsResponse.data || agentsResponse.data.length === 0) {
@@ -115,12 +181,7 @@ export async function handleAgentCommand({
     }
 
     const contextHash = crypto.randomBytes(8).toString('hex')
-    pendingAgentContexts.set(contextHash, {
-      dir: projectDirectory,
-      channelId: targetChannelId,
-      sessionId,
-      isThread,
-    })
+    pendingAgentContexts.set(contextHash, context)
 
     const options = agents.map((agent) => ({
       label: agent.name.slice(0, 100),
@@ -179,18 +240,14 @@ export async function handleAgentSelectMenu(
   }
 
   try {
-    if (context.isThread && context.sessionId) {
-      setSessionAgent(context.sessionId, selectedAgent)
-      agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`)
+    setAgentForContext({ context, agentName: selectedAgent })
 
+    if (context.isThread && context.sessionId) {
       await interaction.editReply({
         content: `Agent preference set for this session: **${selectedAgent}**`,
         components: [],
       })
     } else {
-      setChannelAgent(context.channelId, selectedAgent)
-      agentLogger.log(`Set agent ${selectedAgent} for channel ${context.channelId}`)
-
       await interaction.editReply({
         content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
         components: [],
@@ -206,3 +263,69 @@ export async function handleAgentSelectMenu(
     })
   }
 }
+
+/**
+ * Handle quick agent commands like /plan-agent, /build-agent.
+ * These instantly switch to the specified agent without showing a dropdown.
+ */
+export async function handleQuickAgentCommand({
+  command,
+  appId,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await command.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  // Extract agent name from command: "plan-agent" → "plan"
+  const sanitizedAgentName = command.commandName.replace(/-agent$/, '')
+
+  const context = await resolveAgentCommandContext({ interaction: command, appId })
+  if (!context) {
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(context.dir)
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: context.dir },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await command.editReply({ content: 'No agents available in this project' })
+      return
+    }
+
+    // Find the agent matching the sanitized command name
+    const matchingAgent = agentsResponse.data.find(
+      (a) => sanitizeAgentName(a.name) === sanitizedAgentName
+    )
+
+    if (!matchingAgent) {
+      await command.editReply({
+        content: `Agent not found. Available agents: ${agentsResponse.data.map((a) => a.name).join(', ')}`,
+      })
+      return
+    }
+
+    setAgentForContext({ context, agentName: matchingAgent.name })
+
+    if (context.isThread && context.sessionId) {
+      await command.editReply({
+        content: `Switched to **${matchingAgent.name}** agent for this session`,
+      })
+    } else {
+      await command.editReply({
+        content: `Switched to **${matchingAgent.name}** agent for this channel\n\nAll new sessions will use this agent.`,
+      })
+    }
+  } catch (error) {
+    agentLogger.error('Error in quick agent command:', error)
+    await command.editReply({
+      content: `Failed to switch agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}