kimaki 0.4.24 → 0.4.26

package/dist/voice.js

@@ -1,3 +1,6 @@
+// Audio transcription service using Google Gemini.
+// Transcribes voice messages with code-aware context, using grep/glob tools
+// to verify technical terms, filenames, and function names in the codebase.
 import { GoogleGenAI, Type, } from '@google/genai';
 import { createLogger } from './logger.js';
 import { glob } from 'glob';
@@ -20,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';
     }
 }
@@ -201,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) {
@@ -225,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.
@@ -238,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/dist/worker-types.js

@@ -1 +1,4 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
 export {};

package/dist/xml.js

@@ -1,3 +1,6 @@
+// XML/HTML tag content extractor.
+// Parses XML-like tags from strings (e.g., channel topics) to extract
+// Kimaki configuration like directory paths and app IDs.
 import { DomHandler, Parser, ElementType } from 'htmlparser2';
 import { createLogger } from './logger.js';
 const xmlLogger = createLogger('XML');

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -21,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",
@@ -35,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",

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/ai-tool-to-genai.ts

@@ -1,3 +1,7 @@
+// AI SDK to Google GenAI tool converter.
+// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
+
 import type { Tool, jsonSchema as JsonSchemaType } from 'ai'
 import type {
   FunctionDeclaration,

package/src/channel-management.ts

@@ -1,3 +1,7 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+
 import {
   ChannelType,
   type CategoryChannel,
@@ -8,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()
     },
   )
 
@@ -24,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()
     },
   )
 
@@ -45,7 +59,7 @@ export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryC
   }
 
   return guild.channels.create({
-    name: 'Kimaki Audio',
+    name: categoryName,
     type: ChannelType.GuildCategory,
   })
 }
@@ -54,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}`
@@ -65,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

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// Main CLI entrypoint for the Kimaki Discord bot.
+// Handles interactive setup, Discord OAuth, slash command registration,
+// project channel creation, and launching the bot with opencode integration.
 import { cac } from 'cac'
 import {
   intro,
@@ -24,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,
@@ -50,31 +53,84 @@ process.title = 'kimaki'
 
 const LOCK_PORT = 29988
 
+async function killProcessOnPort(port: number): Promise<boolean> {
+  const isWindows = process.platform === 'win32'
+  const myPid = process.pid
+
+  try {
+    if (isWindows) {
+      // Windows: find PID using netstat, then kill
+      const result = spawnSync('cmd', ['/c', `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`], {
+        shell: false,
+        encoding: 'utf-8',
+      })
+      const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p))
+      // 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})`)
+        spawnSync('taskkill', ['/F', '/PID', targetPid], { shell: false })
+        return true
+      }
+    } else {
+      // Unix: use lsof with -sTCP:LISTEN to only find the listening process
+      const result = spawnSync('lsof', ['-i', `:${port}`, '-sTCP:LISTEN', '-t'], {
+        shell: false,
+        encoding: 'utf-8',
+      })
+      const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p))
+      // Filter out our own PID and take the first (oldest)
+      const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid)
+      if (targetPid) {
+        const pid = parseInt(targetPid, 10)
+        cliLogger.log(`Stopping existing kimaki process (PID: ${pid})`)
+        process.kill(pid, 'SIGKILL')
+        return true
+      }
+    }
+  } catch (e) {
+    cliLogger.debug(`Failed to kill process on port ${port}:`, e)
+  }
+  return false
+}
+
 async function checkSingleInstance(): Promise<void> {
   try {
     const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
       signal: AbortSignal.timeout(1000),
     })
     if (response.ok) {
-      cliLogger.error('Another kimaki instance is already running')
-      process.exit(1)
+      cliLogger.log('Another kimaki instance detected')
+      await killProcessOnPort(LOCK_PORT)
+      // Wait a moment for port to be released
+      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')
   }
 }
 
-function startLockServer(): void {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200)
-    res.end('kimaki')
-  })
-  server.listen(LOCK_PORT, '127.0.0.1')
-  server.on('error', (err: NodeJS.ErrnoException) => {
-    if (err.code === 'EADDRINUSE') {
-      cliLogger.error('Another kimaki instance is already running')
-      process.exit(1)
-    }
+async function startLockServer(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200)
+      res.end('kimaki')
+    })
+    server.listen(LOCK_PORT, '127.0.0.1')
+    server.once('listening', () => {
+      resolve()
+    })
+    server.on('error', async (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE') {
+        cliLogger.log('Port still in use, retrying...')
+        await killProcessOnPort(LOCK_PORT)
+        await new Promise((r) => { setTimeout(r, 500) })
+        // Retry once
+        server.listen(LOCK_PORT, '127.0.0.1')
+      } else {
+        reject(err)
+      }
+    })
   })
 }
 
@@ -97,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')
@@ -176,6 +235,10 @@ async function registerCommands(token: string, appId: string) {
       .setName('abort')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('stop')
+      .setDescription('Abort the current OpenCode request in this thread')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('share')
       .setDescription('Share the current session as a public URL')
@@ -188,8 +251,60 @@ 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')
+      .addStringOption((option) => {
+        option
+          .setName('message')
+          .setDescription('The message to queue')
+          .setRequired(true)
+
+        return option
+      })
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('clear-queue')
+      .setDescription('Clear all queued messages in this thread')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('undo')
+      .setDescription('Undo the last assistant message (revert file changes)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('redo')
+      .setDescription('Redo previously undone changes')
+      .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 {
@@ -607,6 +722,7 @@ async function run({ restart, addChannels }: CliOptions) {
             guild: targetGuild,
             projectDirectory: project.worktree,
             appId,
+            botName: discordClient.user?.username,
           })
 
           createdChannels.push({
@@ -630,8 +746,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!')
     })
@@ -693,7 +838,7 @@ cli
   .action(async (options: { restart?: boolean; addChannels?: boolean }) => {
     try {
       await checkSingleInstance()
-      startLockServer()
+      await startLockServer()
       await run({
         restart: options.restart,
         addChannels: options.addChannels,

package/src/commands/abort.ts

@@ -0,0 +1,94 @@
+// /abort command - Abort the current OpenCode request in this thread.
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { abortControllers } from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('ABORT')
+
+export async function handleAbortCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const textChannel = await resolveTextChannel(channel as ThreadChannel)
+  const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+  if (!directory) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await command.reply({
+      content: 'No active session in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const sessionId = row.session_id
+
+  try {
+    const existingController = abortControllers.get(sessionId)
+    if (existingController) {
+      existingController.abort(new Error('User requested abort'))
+      abortControllers.delete(sessionId)
+    }
+
+    const getClient = await initializeOpencodeForDirectory(directory)
+    await getClient().session.abort({
+      path: { id: sessionId },
+    })
+
+    await command.reply({
+      content: `🛑 Request **aborted**`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    logger.log(`Session ${sessionId} aborted by user`)
+  } catch (error) {
+    logger.error('[ABORT] Error:', error)
+    await command.reply({
+      content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}