kimaki 0.4.25 → 0.4.27

package/dist/voice.js

@@ -23,7 +23,8 @@ async function runGrep({ pattern, directory, }) {
             .join('\n');
         return output.slice(0, 2000);
     }
-    catch {
+    catch (e) {
+        voiceLogger.error('grep search failed:', e);
         return 'grep search failed';
     }
 }
@@ -204,7 +205,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
         });
     }
 }
-export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, sessionMessages, }) {
+export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, currentSessionContext, lastSessionContext, }) {
     try {
         const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
         if (!apiKey) {
@@ -228,6 +229,21 @@ export async function transcribeAudio({ audio, prompt, language, temperature, ge
             throw new Error('Invalid audio format');
         }
         const languageHint = language ? `The audio is in ${language}.\n\n` : '';
+        // build session context section
+        const sessionContextParts = [];
+        if (lastSessionContext) {
+            sessionContextParts.push(`<last_session>
+${lastSessionContext}
+</last_session>`);
+        }
+        if (currentSessionContext) {
+            sessionContextParts.push(`<current_session>
+${currentSessionContext}
+</current_session>`);
+        }
+        const sessionContextSection = sessionContextParts.length > 0
+            ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
+            : '';
         const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
 
 CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
@@ -241,29 +257,29 @@ This is a software development environment. The speaker is giving instructions t
 - File paths, function names, CLI commands, package names, API endpoints
 
 RULES:
-1. You have LIMITED tool calls - use grep/glob sparingly, call them in parallel
-2. If audio is unclear, transcribe your best interpretation
-3. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
-4. When warned about remaining steps, STOP searching and call transcriptionResult immediately
+1. If audio is unclear, transcribe your best interpretation, interpreting words event with strong accents are present, identifying the accent being used first so you can guess what the words meawn
+2. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
+3. Use the session context below to understand technical terms, file names, function names mentioned
 
 Common corrections (apply without tool calls):
 - "reacked" → "React", "jason" → "JSON", "get hub" → "GitHub", "no JS" → "Node.js", "dacker" → "Docker"
 
-Project context for reference:
-<context>
+Project file structure:
+<file_tree>
 ${prompt}
-</context>
-${sessionMessages ? `\nRecent session messages:\n<session_messages>\n${sessionMessages}\n</session_messages>` : ''}
+</file_tree>
+${sessionContextSection}
 
 REMEMBER: Call "transcriptionResult" tool with your transcription. This is mandatory.
 
 Note: "critique" is a CLI tool for showing diffs in the browser.`;
-        const hasDirectory = directory && directory.trim().length > 0;
+        // const hasDirectory = directory && directory.trim().length > 0
         const tools = [
             {
                 functionDeclarations: [
                     transcriptionResultToolDeclaration,
-                    ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+                    // grep/glob disabled - was causing transcription to hang
+                    // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
                 ],
             },
         ];

package/package.json

@@ -2,7 +2,17 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.25",
+  "version": "0.4.27",
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "prepublishOnly": "pnpm tsc",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
+  },
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -11,7 +21,7 @@
     "bin.js"
   ],
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.193",
+    "@opencode-ai/plugin": "^1.1.12",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "@types/js-yaml": "^4.0.9",
@@ -25,7 +35,7 @@
     "@discordjs/opus": "^0.10.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.34.0",
-    "@opencode-ai/sdk": "^1.0.193",
+    "@opencode-ai/sdk": "^1.1.12",
     "@purinton/resampler": "^1.0.4",
     "@snazzah/davey": "^0.1.6",
     "ai": "^5.0.114",
@@ -45,14 +55,5 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1"
-  },
-  "scripts": {
-    "dev": "tsx --env-file .env src/cli.ts",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}

package/src/__snapshots__/compact-session-context-no-system.md

@@ -0,0 +1,35 @@
+[Assistant]: Still not showing. The session might not have a `system` field and the first assistant message might not have `synthetic: true`. Let me add debug logging to see what's available:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a, newString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 | tail -30, description=run test and check output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=grep -i "session keys\|text parts" tmp/kimaki.log | tail -10, description=check debug output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Assistant]: Session doesn't have a `system` field. Let me fix the debug logging:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          , newString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 && grep -i "text parts" , description=run test and check debug, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Assistant]: I see - the first assistant text part has **no `synthetic` field** (it's `undefined`), and it's only 44 chars. The session doesn't expose the system prompt.
+
+Let me remove debug logging and fix the test:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    // Note: OpenCode SDK doesn't expose system prompt directl
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess, newString=  try {
+    const messagesResponse = await client.session.messages({
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.test.ts, oldString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal, newString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal

package/src/__snapshots__/compact-session-context.md

@@ -0,0 +1,47 @@
+[Tool bash]: command=grep -A5 -B5 "Session" node_modules/@opencode-ai/.ignored_sdk/dist/gen/core/types.gen.d.ts 2>/dev/nu, description=check session types, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Tool read]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, offset=248, limit=35
+[Assistant]: Let me update the code to also look for system role messages and fetch session info:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    const messagesResponse = await client.session.messages({
+      path: { id: sessionId },
+, newString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess
+[Tool bash]: command=pnpm vitest run -u --testNamePattern "getCompactSessionContext", description=run tests to check system prompt, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=head -30 discord/src/__snapshots__/compact-session-context.md, description=check if system prompt is in snapshot
+[Assistant]: Still not showing. The session might not have a `system` field and the first assistant message might not have `synthetic: true`. Let me add debug logging to see what's available:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a, newString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 | tail -30, description=run test and check output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=grep -i "session keys\|text parts" tmp/kimaki.log | tail -10, description=check debug output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Assistant]: Session doesn't have a `system` field. Let me fix the debug logging:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          , newString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 && grep -i "text parts" , description=run test and check debug, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Assistant]: I see - the first assistant text part has **no `synthetic` field** (it's `undefined`), and it's only 44 chars. The session doesn't expose the system prompt.
+
+Let me remove debug logging and fix the test:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    // Note: OpenCode SDK doesn't expose system prompt directl
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess, newString=  try {
+    const messagesResponse = await client.session.messages({
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.test.ts, oldString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal, newString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal

package/src/channel-management.ts

@@ -12,14 +12,19 @@ import path from 'node:path'
 import { getDatabase } from './database.js'
 import { extractTagsArrays } from './xml.js'
 
-export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChannel> {
+export async function ensureKimakiCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki'
+
   const existingCategory = guild.channels.cache.find(
     (channel): channel is CategoryChannel => {
       if (channel.type !== ChannelType.GuildCategory) {
         return false
       }
 
-      return channel.name.toLowerCase() === 'kimaki'
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
     },
   )
 
@@ -28,19 +33,24 @@ export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChanne
   }
 
   return guild.channels.create({
-    name: 'Kimaki',
+    name: categoryName,
     type: ChannelType.GuildCategory,
   })
 }
 
-export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryChannel> {
+export async function ensureKimakiAudioCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+
   const existingCategory = guild.channels.cache.find(
     (channel): channel is CategoryChannel => {
       if (channel.type !== ChannelType.GuildCategory) {
         return false
       }
 
-      return channel.name.toLowerCase() === 'kimaki audio'
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
     },
   )
 
@@ -49,7 +59,7 @@ export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryC
   }
 
   return guild.channels.create({
-    name: 'Kimaki Audio',
+    name: categoryName,
     type: ChannelType.GuildCategory,
   })
 }
@@ -58,10 +68,12 @@ export async function createProjectChannels({
   guild,
   projectDirectory,
   appId,
+  botName,
 }: {
   guild: Guild
   projectDirectory: string
   appId: string
+  botName?: string
 }): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
   const baseName = path.basename(projectDirectory)
   const channelName = `${baseName}`
@@ -69,8 +81,8 @@ export async function createProjectChannels({
     .replace(/[^a-z0-9-]/g, '-')
     .slice(0, 100)
 
-  const kimakiCategory = await ensureKimakiCategory(guild)
-  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild)
+  const kimakiCategory = await ensureKimakiCategory(guild, botName)
+  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName)
 
   const textChannel = await guild.channels.create({
     name: channelName,

package/src/cli.ts

@@ -27,7 +27,7 @@ import {
   createProjectChannels,
   type ChannelWithTags,
 } from './discord-bot.js'
-import type { OpencodeClient } from '@opencode-ai/sdk'
+import type { OpencodeClient, Command as OpencodeCommand } from '@opencode-ai/sdk'
 import {
   Events,
   ChannelType,
@@ -82,13 +82,14 @@ async function killProcessOnPort(port: number): Promise<boolean> {
       // Filter out our own PID and take the first (oldest)
       const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid)
       if (targetPid) {
-        cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`)
-        process.kill(parseInt(targetPid, 10), 'SIGKILL')
+        const pid = parseInt(targetPid, 10)
+        cliLogger.log(`Stopping existing kimaki process (PID: ${pid})`)
+        process.kill(pid, 'SIGKILL')
         return true
       }
     }
-  } catch {
-    // Failed to kill, continue anyway
+  } catch (e) {
+    cliLogger.debug(`Failed to kill process on port ${port}:`, e)
   }
   return false
 }
@@ -105,7 +106,7 @@ async function checkSingleInstance(): Promise<void> {
       await new Promise((resolve) => { setTimeout(resolve, 500) })
     }
   } catch {
-    // Connection refused means no instance running, continue
+    cliLogger.debug('No other kimaki instance detected on lock port')
   }
 }
 
@@ -152,7 +153,10 @@ type CliOptions = {
   addChannels?: boolean
 }
 
-async function registerCommands(token: string, appId: string) {
+// Commands to skip when registering user commands (reserved names)
+const SKIP_USER_COMMANDS = ['init']
+
+async function registerCommands(token: string, appId: string, userCommands: OpencodeCommand[] = []) {
   const commands = [
     new SlashCommandBuilder()
       .setName('resume')
@@ -216,19 +220,11 @@ async function registerCommands(token: string, appId: string) {
       })
       .toJSON(),
     new SlashCommandBuilder()
-      .setName('accept')
-      .setDescription('Accept a pending permission request (this request only)')
-      .toJSON(),
-    new SlashCommandBuilder()
-      .setName('accept-always')
-      .setDescription('Accept and auto-approve future requests matching this pattern')
-      .toJSON(),
-    new SlashCommandBuilder()
-      .setName('reject')
-      .setDescription('Reject a pending permission request')
+      .setName('abort')
+      .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
     new SlashCommandBuilder()
-      .setName('abort')
+      .setName('stop')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
     new SlashCommandBuilder()
@@ -243,6 +239,10 @@ async function registerCommands(token: string, appId: string) {
       .setName('model')
       .setDescription('Set the preferred model for this channel or session')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('agent')
+      .setDescription('Set the preferred agent for this channel or session')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('queue')
       .setDescription('Queue a message to be sent after the current response finishes')
@@ -269,6 +269,30 @@ async function registerCommands(token: string, appId: string) {
       .toJSON(),
   ]
 
+  // Add user-defined commands with -cmd suffix
+  for (const cmd of userCommands) {
+    if (SKIP_USER_COMMANDS.includes(cmd.name)) {
+      continue
+    }
+
+    const commandName = `${cmd.name}-cmd`
+    const description = cmd.description || `Run /${cmd.name} command`
+
+    commands.push(
+      new SlashCommandBuilder()
+        .setName(commandName)
+        .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
+        .addStringOption((option) => {
+          option
+            .setName('arguments')
+            .setDescription('Arguments to pass to the command')
+            .setRequired(false)
+          return option
+        })
+        .toJSON(),
+    )
+  }
+
   const rest = new REST().setToken(token)
 
   try {
@@ -686,6 +710,7 @@ async function run({ restart, addChannels }: CliOptions) {
             guild: targetGuild,
             projectDirectory: project.worktree,
             appId,
+            botName: discordClient.user?.username,
           })
 
           createdChannels.push({
@@ -709,8 +734,37 @@ async function run({ restart, addChannels }: CliOptions) {
     }
   }
 
+  // Fetch user-defined commands using the already-running server
+  const allUserCommands: OpencodeCommand[] = []
+  try {
+    const commandsResponse = await getClient().command.list({
+      query: { directory: currentDir },
+    })
+    if (commandsResponse.data) {
+      allUserCommands.push(...commandsResponse.data)
+    }
+  } catch {
+    // Ignore errors fetching commands
+  }
+
+  // Log available user commands
+  const registrableCommands = allUserCommands.filter(
+    (cmd) => !SKIP_USER_COMMANDS.includes(cmd.name),
+  )
+
+  if (registrableCommands.length > 0) {
+    const commandList = registrableCommands
+      .map((cmd) => `  /${cmd.name}-cmd - ${cmd.description || 'No description'}`)
+      .join('\n')
+
+    note(
+      `Found ${registrableCommands.length} user-defined command(s):\n${commandList}`,
+      'OpenCode Commands',
+    )
+  }
+
   cliLogger.log('Registering slash commands asynchronously...')
-  void registerCommands(token, appId)
+  void registerCommands(token, appId, allUserCommands)
     .then(() => {
       cliLogger.log('Slash commands registered!')
     })

package/src/commands/add-project.ts

@@ -67,6 +67,7 @@ export async function handleAddProjectCommand({
         guild,
         projectDirectory: directory,
         appId,
+        botName: command.client.user?.username,
       })
 
     await command.editReply(

package/src/commands/agent.ts

@@ -0,0 +1,201 @@
+// /agent command - Set the preferred agent for this channel or session.
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const agentLogger = createLogger('AGENT')
+
+const pendingAgentContexts = new Map<string, {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}>()
+
+export async function handleAgentCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await interaction.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.editReply({ content: 'This command can only be used in a channel' })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = textChannel?.id || channel.id
+
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+    sessionId = row?.session_id
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({ content: 'This command can only be used in text channels or threads' })
+    return
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await interaction.editReply({ content: 'This channel is not configured for this bot' })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({ content: 'This channel is not configured with a project directory' })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: projectDirectory },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await interaction.editReply({ content: 'No agents available' })
+      return
+    }
+
+    const agents = agentsResponse.data
+      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .slice(0, 25)
+
+    if (agents.length === 0) {
+      await interaction.editReply({ content: 'No primary agents available' })
+      return
+    }
+
+    const contextHash = crypto.randomBytes(8).toString('hex')
+    pendingAgentContexts.set(contextHash, {
+      dir: projectDirectory,
+      channelId: targetChannelId,
+      sessionId,
+      isThread,
+    })
+
+    const options = agents.map((agent) => ({
+      label: agent.name.slice(0, 100),
+      value: agent.name,
+      description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+    }))
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`agent_select:${contextHash}`)
+      .setPlaceholder('Select an agent')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: '**Set Agent Preference**\nSelect an agent:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    agentLogger.error('Error loading agents:', error)
+    await interaction.editReply({
+      content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+export async function handleAgentSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('agent_select:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('agent_select:', '')
+  const context = pendingAgentContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.editReply({
+      content: 'Selection expired. Please run /agent again.',
+      components: [],
+    })
+    return
+  }
+
+  const selectedAgent = interaction.values[0]
+  if (!selectedAgent) {
+    await interaction.editReply({
+      content: 'No agent selected',
+      components: [],
+    })
+    return
+  }
+
+  try {
+    if (context.isThread && context.sessionId) {
+      setSessionAgent(context.sessionId, selectedAgent)
+      agentLogger.log(`Set agent ${selectedAgent} for session ${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: [],
+      })
+    }
+
+    pendingAgentContexts.delete(contextHash)
+  } catch (error) {
+    agentLogger.error('Error saving agent preference:', error)
+    await interaction.editReply({
+      content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}