kimaki 0.4.36 → 0.4.38

package/src/database.ts

@@ -61,6 +61,21 @@ export function getDatabase(): Database.Database {
       )
     `)
 
+    // Migration: add app_id column to channel_directories for multi-bot support
+    try {
+      db.exec(`ALTER TABLE channel_directories ADD COLUMN app_id TEXT`)
+    } 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,
@@ -169,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

@@ -187,17 +187,6 @@ export async function startDiscordBot({
         const thread = channel as ThreadChannel
         discordLogger.log(`Message in thread ${thread.name} (${thread.id})`)
 
-        const row = getDatabase()
-          .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
-          .get(thread.id) as { session_id: string } | undefined
-
-        if (!row) {
-          discordLogger.log(`No session found for thread ${thread.id}`)
-          return
-        }
-
-        voiceLogger.log(`[SESSION] Found session ${row.session_id} for thread ${thread.id}`)
-
         const parent = thread.parent as TextChannel | null
         let projectDirectory: string | undefined
         let channelAppId: string | undefined
@@ -228,6 +217,37 @@ export async function startDiscordBot({
           return
         }
 
+        const row = getDatabase()
+          .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+          .get(thread.id) as { session_id: string } | undefined
+
+        // No existing session - start a new one (e.g., replying to a notification thread)
+        if (!row) {
+          discordLogger.log(`No session for thread ${thread.id}, starting new session`)
+          
+          if (!projectDirectory) {
+            discordLogger.log(`Cannot start session: no project directory for thread ${thread.id}`)
+            return
+          }
+
+          // Include starter message as context for the session
+          let prompt = message.content
+          const starterMessage = await thread.fetchStarterMessage().catch(() => null)
+          if (starterMessage?.content && starterMessage.content !== message.content) {
+            prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`
+          }
+
+          await handleOpencodeSession({
+            prompt,
+            thread,
+            projectDirectory,
+            channelId: parent?.id || '',
+          })
+          return
+        }
+
+        voiceLogger.log(`[SESSION] Found session ${row.session_id} for thread ${thread.id}`)
+
         let messageContent = message.content || ''
 
         let currentSessionContext: string | undefined
@@ -393,42 +413,42 @@ export async function startDiscordBot({
     }
   })
 
-  // Magic prefix used by `kimaki start-session` CLI command to initiate sessions
-  const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
-
-  // Handle bot-initiated threads created by `kimaki start-session`
+  // 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) {

package/src/system-message.ts

@@ -36,7 +36,11 @@ ${
 
 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.)
 `