kimaki 0.4.37 → 0.4.38

package/dist/channel-management.js

@@ -6,7 +6,9 @@ import path from 'node:path';
 import { getDatabase } from './database.js';
 import { extractTagsArrays } from './xml.js';
 export async function ensureKimakiCategory(guild, botName) {
-    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) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;
@@ -22,7 +24,9 @@ export async function ensureKimakiCategory(guild, botName) {
     });
 }
 export async function ensureKimakiAudioCategory(guild, botName) {
-    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) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;

package/dist/cli.js

@@ -14,6 +14,7 @@ import { spawn, spawnSync, execSync } from 'node:child_process';
 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');
 process.title = 'kimaki';
@@ -119,7 +120,7 @@ async function startLockServer() {
 const EXIT_NO_RESTART = 64;
 // Commands to skip when registering user commands (reserved names)
 const SKIP_USER_COMMANDS = ['init'];
-async function registerCommands(token, appId, userCommands = []) {
+async function registerCommands({ token, appId, userCommands = [], agents = [], }) {
     const commands = [
         new SlashCommandBuilder()
             .setName('resume')
@@ -254,6 +255,18 @@ async function registerCommands(token, appId, userCommands = []) {
         })
             .toJSON());
     }
+    // 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 {
         const data = (await rest.put(Routes.applicationCommands(appId), {
@@ -506,8 +519,8 @@ async function run({ restart, addChannels }) {
     const getClient = await opencodePromise;
     s.stop('OpenCode server ready!');
     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 || [])
@@ -521,6 +534,10 @@ async function run({ restart, addChannels }) {
             .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)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
@@ -611,7 +628,7 @@ async function run({ restart, addChannels }) {
         note(`Found ${registrableCommands.length} user-defined command(s):\n${commandList}`, 'OpenCode Commands');
     }
     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!');
     })
@@ -746,12 +763,6 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
-// 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**';
-// Notify-only prefix - bot won't start a session, just creates thread for notifications.
-// Reply to the thread to start a session with the notification as context.
-const BOT_NOTIFY_PREFIX = '📢 **Notification**';
 cli
     .command('send', 'Send a message to Discord channel, creating a thread. Use --notify-only to skip AI session.')
     .alias('start-session') // backwards compatibility
@@ -953,9 +964,7 @@ cli
             throw new Error(`Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`);
         }
         s.message('Creating starter message...');
-        // Create starter message with magic prefix
-        // BOT_SESSION_PREFIX triggers AI session, BOT_NOTIFY_PREFIX is notification-only
-        const messagePrefix = notifyOnly ? BOT_NOTIFY_PREFIX : BOT_SESSION_PREFIX;
+        // Create starter message with just the prompt (no prefix)
         const starterMessageResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
             method: 'POST',
             headers: {
@@ -963,7 +972,7 @@ cli
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
-                content: `${messagePrefix}\n${prompt}`,
+                content: prompt,
             }),
         });
         if (!starterMessageResponse.ok) {
@@ -992,6 +1001,17 @@ cli
             throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
         }
         const threadData = (await threadResponse.json());
+        // 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}`;
         const successMessage = notifyOnly

package/dist/commands/agent.js

@@ -1,19 +1,29 @@
 // /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, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, } 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';
 const agentLogger = createLogger('AGENT');
 const pendingAgentContexts = new Map();
-export async function handleAgentCommand({ interaction, appId, }) {
-    await interaction.deferReply({ ephemeral: true });
-    runModelMigrations();
+/**
+ * Sanitize an agent name to be a valid Discord command name component.
+ * Lowercase, alphanumeric and hyphens only.
+ */
+export function sanitizeAgentName(name) {
+    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, }) {
     const channel = interaction.channel;
     if (!channel) {
         await interaction.editReply({ content: 'This command can only be used in a channel' });
-        return;
+        return null;
     }
     const isThread = [
         ChannelType.PublicThread,
@@ -47,22 +57,53 @@ export async function handleAgentCommand({ interaction, appId, }) {
         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, }) {
+    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, }) {
+    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) {
             await interaction.editReply({ content: 'No agents available' });
@@ -76,12 +117,7 @@ export async function handleAgentCommand({ interaction, appId, }) {
             return;
         }
         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),
             value: agent.name,
@@ -128,17 +164,14 @@ export async function handleAgentSelectMenu(interaction) {
         return;
     }
     try {
+        setAgentForContext({ context, agentName: selectedAgent });
         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: [],
@@ -154,3 +187,52 @@ export async function handleAgentSelectMenu(interaction) {
         });
     }
 }
+/**
+ * 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, }) {
+    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'}`,
+        });
+    }
+}

package/dist/database.js

@@ -57,6 +57,13 @@ export function getDatabase() {
         catch {
             // Column already exists, ignore
         }
+        // Table for threads that should auto-start a session (created by CLI without --notify-only)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_auto_start (
+        thread_id TEXT PRIMARY KEY,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
         db.exec(`
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
@@ -147,6 +154,14 @@ export function setSessionModel(sessionId, modelId) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`).run(sessionId, modelId);
 }
+/**
+ * Clear the model preference for a session.
+ * Used when switching agents so the agent's model takes effect.
+ */
+export function clearSessionModel(sessionId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM session_models WHERE session_id = ?').run(sessionId);
+}
 /**
  * Get the agent preference for a channel.
  */

package/dist/discord-bot.js

@@ -152,17 +152,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         discordLogger.log(`Cannot start session: no project directory for thread ${thread.id}`);
                         return;
                     }
-                    // Include starter message (notification) as context for the session
+                    // Include starter message as context for the session
                     let prompt = message.content;
                     const starterMessage = await thread.fetchStarterMessage().catch(() => null);
-                    if (starterMessage?.content) {
-                        // Strip notification prefix if present
-                        const notificationContent = starterMessage.content
-                            .replace(/^📢 \*\*Notification\*\*\n?/, '')
-                            .trim();
-                        if (notificationContent) {
-                            prompt = `Context from notification:\n${notificationContent}\n\nUser request:\n${message.content}`;
-                        }
+                    if (starterMessage?.content && starterMessage.content !== message.content) {
+                        prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`;
                     }
                     await handleOpencodeSession({
                         prompt,
@@ -316,35 +310,35 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
         }
     });
-    // Magic prefix used by `kimaki send` CLI command to initiate sessions
-    const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**';
-    // Handle bot-initiated threads created by `kimaki send`
+    // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
         try {
             if (!newlyCreated) {
                 return;
             }
+            // Check if this thread is marked for auto-start in the database
+            const db = getDatabase();
+            const pendingRow = db
+                .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
+                .get(thread.id);
+            if (!pendingRow) {
+                return; // Not a CLI-initiated auto-start thread
+            }
+            // Remove from pending table
+            db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id);
+            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
             // Only handle threads in text channels
             const parent = thread.parent;
             if (!parent || parent.type !== ChannelType.GuildText) {
                 return;
             }
-            // Get the starter message to check for magic prefix
+            // Get the starter message for the prompt
             const starterMessage = await thread.fetchStarterMessage().catch(() => null);
             if (!starterMessage) {
                 discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`);
                 return;
             }
-            // Only handle messages from this bot with the magic prefix
-            if (starterMessage.author.id !== discordClient.user?.id) {
-                return;
-            }
-            if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
-                return;
-            }
-            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
-            // Extract the prompt (everything after the prefix)
-            const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim();
+            const prompt = starterMessage.content.trim();
             if (!prompt) {
                 discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);
                 return;

package/dist/interaction-handler.js

@@ -12,7 +12,7 @@ import { handleAbortCommand } from './commands/abort.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
-import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js';
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand } from './commands/agent.js';
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
@@ -94,6 +94,11 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleRedoCommand({ command: interaction, appId });
                         return;
                 }
+                // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+                if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {
+                    await handleQuickAgentCommand({ command: interaction, appId });
+                    return;
+                }
                 // Handle user-defined commands (ending with -cmd suffix)
                 if (interaction.commandName.endsWith('-cmd')) {
                     await handleUserCommand({ command: interaction, appId });

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/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.37",
+  "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) {

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 {
@@ -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,12 +1032,7 @@ 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**'
-// Notify-only prefix - bot won't start a session, just creates thread for notifications.
-// Reply to the thread to start a session with the notification as context.
-const BOT_NOTIFY_PREFIX = '📢 **Notification**'
+
 
 cli
   .command(
@@ -1263,9 +1291,7 @@ cli
 
       s.message('Creating starter message...')
 
-      // Create starter message with magic prefix
-      // BOT_SESSION_PREFIX triggers AI session, BOT_NOTIFY_PREFIX is notification-only
-      const messagePrefix = notifyOnly ? BOT_NOTIFY_PREFIX : BOT_SESSION_PREFIX
+      // Create starter message with just the prompt (no prefix)
       const starterMessageResponse = await fetch(
         `https://discord.com/api/v10/channels/${channelId}/messages`,
         {
@@ -1275,7 +1301,7 @@ cli
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
-            content: `${messagePrefix}\n${prompt}`,
+            content: prompt,
           }),
         },
       )
@@ -1315,6 +1341,19 @@ 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}`

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'}`,
+    })
+  }
+}

package/src/database.ts

@@ -68,6 +68,14 @@ export function getDatabase(): Database.Database {
       // Column already exists, ignore
     }
 
+    // Table for threads that should auto-start a session (created by CLI without --notify-only)
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_auto_start (
+        thread_id TEXT PRIMARY KEY,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
     db.exec(`
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
@@ -176,6 +184,15 @@ export function setSessionModel(sessionId: string, modelId: string): void {
   )
 }
 
+/**
+ * Clear the model preference for a session.
+ * Used when switching agents so the agent's model takes effect.
+ */
+export function clearSessionModel(sessionId: string): void {
+  const db = getDatabase()
+  db.prepare('DELETE FROM session_models WHERE session_id = ?').run(sessionId)
+}
+
 /**
  * Get the agent preference for a channel.
  */

package/src/discord-bot.ts

@@ -230,17 +230,11 @@ export async function startDiscordBot({
             return
           }
 
-          // Include starter message (notification) as context for the session
+          // Include starter message as context for the session
           let prompt = message.content
           const starterMessage = await thread.fetchStarterMessage().catch(() => null)
-          if (starterMessage?.content) {
-            // Strip notification prefix if present
-            const notificationContent = starterMessage.content
-              .replace(/^📢 \*\*Notification\*\*\n?/, '')
-              .trim()
-            if (notificationContent) {
-              prompt = `Context from notification:\n${notificationContent}\n\nUser request:\n${message.content}`
-            }
+          if (starterMessage?.content && starterMessage.content !== message.content) {
+            prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`
           }
 
           await handleOpencodeSession({
@@ -419,42 +413,42 @@ export async function startDiscordBot({
     }
   })
 
-  // Magic prefix used by `kimaki send` CLI command to initiate sessions
-  const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
-
-  // Handle bot-initiated threads created by `kimaki send`
+  // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
   discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
     try {
       if (!newlyCreated) {
         return
       }
 
+      // Check if this thread is marked for auto-start in the database
+      const db = getDatabase()
+      const pendingRow = db
+        .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
+        .get(thread.id) as { thread_id: string } | undefined
+
+      if (!pendingRow) {
+        return // Not a CLI-initiated auto-start thread
+      }
+
+      // Remove from pending table
+      db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id)
+
+      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
+
       // Only handle threads in text channels
       const parent = thread.parent as TextChannel | null
       if (!parent || parent.type !== ChannelType.GuildText) {
         return
       }
 
-      // Get the starter message to check for magic prefix
+      // Get the starter message for the prompt
       const starterMessage = await thread.fetchStarterMessage().catch(() => null)
       if (!starterMessage) {
         discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`)
         return
       }
 
-      // Only handle messages from this bot with the magic prefix
-      if (starterMessage.author.id !== discordClient.user?.id) {
-        return
-      }
-
-      if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
-        return
-      }
-
-      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
-
-      // Extract the prompt (everything after the prefix)
-      const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim()
+      const prompt = starterMessage.content.trim()
       if (!prompt) {
         discordLogger.log(`[BOT_SESSION] No prompt found in starter message`)
         return

package/src/interaction-handler.ts

@@ -20,7 +20,7 @@ import {
   handleProviderSelectMenu,
   handleModelSelectMenu,
 } from './commands/model.js'
-import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js'
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand } from './commands/agent.js'
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
@@ -136,6 +136,12 @@ export function registerInteractionHandler({
             return
         }
 
+        // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+        if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {
+          await handleQuickAgentCommand({ command: interaction, appId })
+          return
+        }
+
         // Handle user-defined commands (ending with -cmd suffix)
         if (interaction.commandName.endsWith('-cmd')) {
           await handleUserCommand({ command: interaction, appId })

package/src/session-handler.ts

@@ -641,6 +641,39 @@ export async function handleOpencodeSession({
             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
           if (event.properties.sessionID === session.id) {
@@ -774,10 +807,23 @@ export async function handleOpencodeSession({
     const parts = [{ type: 'text' as const, 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
       }
@@ -790,13 +836,6 @@ export async function handleOpencodeSession({
       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({
@@ -850,9 +889,8 @@ export async function handleOpencodeSession({
 
     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) {