kimaki 0.4.37 → 0.4.39

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

@@ -9,11 +9,13 @@ import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDis
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
 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 +121,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 +256,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), excluding hidden agents
+    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
+    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), {
@@ -419,7 +433,12 @@ async function run({ restart, addChannels }) {
     // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
     const currentDir = process.cwd();
     s.start('Starting OpenCode server...');
-    const opencodePromise = initializeOpencodeForDirectory(currentDir);
+    const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
+        if (errore.isError(result)) {
+            throw new Error(result.message);
+        }
+        return result;
+    });
     s.message('Connecting to Discord...');
     const discordClient = await createDiscordClient();
     const guilds = [];
@@ -506,8 +525,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 +540,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 +634,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 +769,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 +970,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 +978,7 @@ cli
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
-                content: `${messagePrefix}\n${prompt}`,
+                content: prompt,
             }),
         });
         if (!starterMessageResponse.ok) {
@@ -992,6 +1007,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/abort.js

@@ -5,6 +5,7 @@ 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';
+import * as errore from 'errore';
 const logger = createLogger('ABORT');
 export async function handleAbortCommand({ command }) {
     const channel = command.channel;
@@ -51,13 +52,21 @@ export async function handleAbortCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    const existingController = abortControllers.get(sessionId);
+    if (existingController) {
+        existingController.abort(new Error('User requested abort'));
+        abortControllers.delete(sessionId);
+    }
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.reply({
+            content: `Failed to abort: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     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 },
         });

package/dist/commands/add-project.js

@@ -6,6 +6,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
 import { createLogger } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
+import * as errore from 'errore';
 const logger = createLogger('ADD-PROJECT');
 export async function handleAddProjectCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -18,6 +19,10 @@ export async function handleAddProjectCommand({ command, appId }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             await command.editReply('Failed to fetch projects');
@@ -60,6 +65,10 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             await interaction.respond([]);

package/dist/commands/agent.js

@@ -1,19 +1,30 @@
 // /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';
+import * as errore from 'errore';
 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,41 +58,74 @@ 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);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
         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' });
             return;
         }
         const agents = agentsResponse.data
-            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .filter((agent) => {
+            const hidden = agent.hidden;
+            return (agent.mode === 'primary' || agent.mode === 'all') && !hidden;
+        })
             .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,
-        });
+        pendingAgentContexts.set(contextHash, context);
         const options = agents.map((agent) => ({
             label: agent.name.slice(0, 100),
             value: agent.name,
@@ -128,17 +172,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 +195,56 @@ 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);
+        if (errore.isError(getClient)) {
+            await command.editReply({ content: getClient.message });
+            return;
+        }
+        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/commands/fork.js

@@ -5,6 +5,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const sessionLogger = createLogger('SESSION');
 const forkLogger = createLogger('FORK');
 export async function handleForkCommand(interaction) {
@@ -50,8 +51,14 @@ export async function handleForkCommand(interaction) {
     // Defer reply before API calls to avoid 3-second timeout
     await interaction.deferReply({ ephemeral: true });
     const sessionId = row.session_id;
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await interaction.editReply({
+            content: `Failed to load messages: ${getClient.message}`,
+        });
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const messagesResponse = await getClient().session.messages({
             path: { id: sessionId },
         });
@@ -120,8 +127,12 @@ export async function handleForkSelectMenu(interaction) {
         return;
     }
     await interaction.deferReply({ ephemeral: false });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await interaction.editReply(`Failed to fork session: ${getClient.message}`);
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const forkResponse = await getClient().session.fork({
             path: { id: sessionId },
             body: { messageID: selectedMessageId },

package/dist/commands/model.js

@@ -6,6 +6,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { abortAndRetrySession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const modelLogger = createLogger('MODEL');
 // Store context by hash to avoid customId length limits (Discord max: 100 chars)
 const pendingModelContexts = new Map();
@@ -77,6 +78,10 @@ export async function handleModelCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
         const providersResponse = await getClient().provider.list({
             query: { directory: projectDirectory },
         });
@@ -162,6 +167,13 @@ export async function handleProviderSelectMenu(interaction) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
         const providersResponse = await getClient().provider.list({
             query: { directory: context.dir },
         });

package/dist/commands/remove-project.js

@@ -1,5 +1,6 @@
 // /remove-project command - Remove Discord channels for a project.
 import path from 'node:path';
+import * as errore from 'errore';
 import { getDatabase } from '../database.js';
 import { createLogger } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
@@ -25,20 +26,27 @@ export async function handleRemoveProjectCommand({ command, appId }) {
         const deletedChannels = [];
         const failedChannels = [];
         for (const { channel_id, channel_type } of channels) {
-            try {
-                const channel = await guild.channels.fetch(channel_id).catch(() => null);
-                if (channel) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (errore.isError(channel)) {
+                logger.error(`Failed to fetch channel ${channel_id}:`, channel);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+                continue;
+            }
+            if (channel) {
+                try {
                     await channel.delete(`Removed by /remove-project command`);
                     deletedChannels.push(`${channel_type}: ${channel_id}`);
                 }
-                else {
-                    // Channel doesn't exist in this guild or was already deleted
-                    deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+                catch (error) {
+                    logger.error(`Failed to delete channel ${channel_id}:`, error);
+                    failedChannels.push(`${channel_type}: ${channel_id}`);
                 }
             }
-            catch (error) {
-                logger.error(`Failed to delete channel ${channel_id}:`, error);
-                failedChannels.push(`${channel_type}: ${channel_id}`);
+            else {
+                deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
             }
         }
         // Remove from database
@@ -76,14 +84,16 @@ export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
         // Filter to only channels that exist in this guild
         const projectsInGuild = [];
         for (const { directory, channel_id } of allChannels) {
-            try {
-                const channel = await guild.channels.fetch(channel_id).catch(() => null);
-                if (channel) {
-                    projectsInGuild.push({ directory, channelId: channel_id });
-                }
-            }
-            catch {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (errore.isError(channel)) {
                 // Channel not in this guild, skip
+                continue;
+            }
+            if (channel) {
+                projectsInGuild.push({ directory, channelId: channel_id });
             }
         }
         const projects = projectsInGuild

package/dist/commands/resume.js

@@ -7,6 +7,7 @@ import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../dis
 import { extractTagsArrays } from '../xml.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('RESUME');
 export async function handleResumeCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -41,6 +42,10 @@ export async function handleResumeCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const sessionResponse = await getClient().session.get({
             path: { id: sessionId },
         });
@@ -111,6 +116,10 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const sessionsResponse = await getClient().session.list();
         if (!sessionsResponse.data) {
             await interaction.respond([]);

package/dist/commands/session.js

@@ -8,6 +8,7 @@ import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { extractTagsArrays } from '../xml.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('SESSION');
 export async function handleSessionCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -44,6 +45,10 @@ export async function handleSessionCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const files = filesString
             .split(',')
             .map((f) => f.trim())
@@ -102,6 +107,10 @@ async function handleAgentAutocomplete({ interaction, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const agentsResponse = await getClient().app.agents({
             query: { directory: projectDirectory },
         });
@@ -165,6 +174,10 @@ export async function handleSessionAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const response = await getClient().find.files({
             query: {
                 query: currentQuery || '',

package/dist/commands/share.js

@@ -4,6 +4,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('SHARE');
 export async function handleShareCommand({ command }) {
     const channel = command.channel;
@@ -50,8 +51,16 @@ export async function handleShareCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.reply({
+            content: `Failed to share session: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const response = await getClient().session.share({
             path: { id: sessionId },
         });