kimaki 0.4.55 → 0.4.56

package/dist/cli.js

@@ -6,7 +6,10 @@ import { cac } from '@xmorse/cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, abbreviatePath } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
-import { getBotToken, setBotToken, setGeminiApiKey, setChannelDirectory, findChannelsByDirectory, findChannelByAppId, getThreadSession, getThreadIdBySessionId, setPendingAutoStart, } from './database.js';
+import { getBotToken, setBotToken, setChannelDirectory, findChannelsByDirectory, findChannelByAppId, getThreadSession, getThreadIdBySessionId, } from './database.js';
+import { formatWorktreeName } from './commands/worktree.js';
+import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
+import yaml from 'js-yaml';
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
@@ -15,7 +18,7 @@ import { createLogger, LogPrefix } from './logger.js';
 import { uploadFilesToDiscord } from './discord-utils.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
-import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity } from './config.js';
+import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity, setDefaultMentionMode } from './config.js';
 import { sanitizeAgentName } from './commands/agent.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 // Strip bracketed paste escape sequences from terminal input.
@@ -165,6 +168,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setAutocomplete(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-session')
@@ -188,6 +192,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setAutocomplete(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-worktree')
@@ -199,14 +204,22 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setRequired(false);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('merge-worktree')
             .setDescription('Merge the worktree branch into the default branch')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('toggle-worktrees')
             .setDescription('Toggle automatic git worktree creation for new sessions in this channel')
+            .setDMPermission(false)
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('toggle-mention-mode')
+            .setDescription('Toggle mention-only mode (bot only responds when @mentioned)')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
@@ -219,6 +232,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setAutocomplete(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('remove-project')
@@ -231,6 +245,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setAutocomplete(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('create-new-project')
@@ -239,38 +254,57 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             option.setName('name').setDescription('Name for the new project folder').setRequired(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('abort')
             .setDescription('Abort the current OpenCode request in this thread')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('compact')
             .setDescription('Compact the session context by summarizing conversation history')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('stop')
             .setDescription('Abort the current OpenCode request in this thread')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('share')
             .setDescription('Share the current session as a public URL')
+            .setDMPermission(false)
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('diff')
+            .setDescription('Show git diff as a shareable URL')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('fork')
             .setDescription('Fork the session from a past user message')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('model')
             .setDescription('Set the preferred model for this channel or session')
+            .setDMPermission(false)
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('unset-model-override')
+            .setDescription('Remove model override and use default instead')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('login')
             .setDescription('Authenticate with an AI provider (OAuth or API key). Use this instead of /connect')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('agent')
             .setDescription('Set the preferred agent for this channel or session')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('queue')
@@ -279,18 +313,22 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             option.setName('message').setDescription('The message to queue').setRequired(true);
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('clear-queue')
             .setDescription('Clear all queued messages in this thread')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('undo')
             .setDescription('Undo the last assistant message (revert file changes)')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('redo')
             .setDescription('Redo previously undone changes')
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('verbosity')
@@ -303,10 +341,12 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .addChoices({ name: 'tools-and-text (default)', value: 'tools-and-text' }, { name: 'text-and-essential-tools', value: 'text-and-essential-tools' }, { name: 'text-only', value: 'text-only' });
             return option;
         })
+            .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()
             .setName('restart-opencode-server')
             .setDescription('Restart the opencode server for this channel only (fixes state/auth/plugins)')
+            .setDMPermission(false)
             .toJSON(),
     ];
     // Add user-defined commands with -cmd suffix
@@ -315,7 +355,8 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             continue;
         }
         // Sanitize command name: oh-my-opencode uses MCP commands with colons, which Discord doesn't allow
-        const sanitizedName = cmd.name.replace(/:/g, '-');
+        // Also convert to lowercase since Discord only allows lowercase in command names
+        const sanitizedName = cmd.name.toLowerCase().replace(/:/g, '-');
         const commandName = `${sanitizedName}-cmd`;
         const description = cmd.description || `Run /${cmd.name} command`;
         commands.push(new SlashCommandBuilder()
@@ -328,6 +369,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setRequired(false);
             return option;
         })
+            .setDMPermission(false)
             .toJSON());
     }
     // Add agent-specific quick commands like /plan-agent, /build-agent
@@ -340,6 +382,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
         commands.push(new SlashCommandBuilder()
             .setName(commandName.slice(0, 32)) // Discord limits to 32 chars
             .setDescription(description.slice(0, 100))
+            .setDMPermission(false)
             .toJSON());
     }
     const rest = new REST().setToken(token);
@@ -574,29 +617,7 @@ async function run({ restart, addChannels, useWorktrees, enableVoiceChannels })
             process.exit(0);
         }
         token = stripBracketedPaste(tokenInput);
-        note(`You can get a Gemini api Key at https://aistudio.google.com/apikey`, `Gemini API Key`);
-        const geminiApiKeyInput = await password({
-            message: 'Enter your Gemini API Key for voice channels and audio transcription (optional, press Enter to skip):',
-            validate(value) {
-                const cleaned = stripBracketedPaste(value);
-                if (cleaned && cleaned.length < 10) {
-                    return 'Invalid API key format';
-                }
-                return undefined;
-            },
-        });
-        if (isCancel(geminiApiKeyInput)) {
-            cancel('Setup cancelled');
-            process.exit(0);
-        }
-        const geminiApiKey = stripBracketedPaste(geminiApiKeyInput) || null;
-        // Store bot token early so setGeminiApiKey can satisfy FK constraint
         await setBotToken(appId, token);
-        // Store API key in database
-        if (geminiApiKey) {
-            await setGeminiApiKey(appId, geminiApiKey);
-            note('API key saved successfully', 'API Key Stored');
-        }
         note(`Bot install URL:\n${generateBotInstallUrl({ clientId: appId })}\n\nYou MUST install the bot in your Discord server before continuing.`, 'Step 4: Install Bot to Server');
         const installed = await text({
             message: 'Press Enter AFTER you have installed the bot in your server:',
@@ -845,6 +866,7 @@ cli
     .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
     .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
     .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
+    .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -861,6 +883,10 @@ cli
             setDefaultVerbosity(options.verbosity);
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }
+        if (options.mentionMode) {
+            setDefaultMentionMode(true);
+            cliLogger.log('Default mention mode: enabled (bot only responds when @mentioned)');
+        }
         if (options.installUrl) {
             await initDatabase();
             const existingBot = await getBotToken();
@@ -942,6 +968,10 @@ cli
     .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
     .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
     .option('--notify-only', 'Create notification thread without starting AI session')
+    .option('--worktree [name]', 'Create git worktree for session (name optional, derives from thread name)')
+    .option('-u, --user <username>', 'Discord username to add to thread')
+    .option('--agent <agent>', 'Agent to use for the session')
+    .option('--model <model>', 'Model to use (format: provider/model)')
     .action(async (options) => {
     try {
         let { channel: channelId, prompt, name, appId: optionAppId, notifyOnly } = options;
@@ -962,6 +992,10 @@ cli
             cliLogger.error('Prompt is required. Use --prompt <prompt>');
             process.exit(EXIT_NO_RESTART);
         }
+        if (options.worktree && notifyOnly) {
+            cliLogger.error('Cannot use --worktree with --notify-only');
+            process.exit(EXIT_NO_RESTART);
+        }
         // Get bot token from env var or database
         const envToken = process.env.KIMAKI_BOT_TOKEN;
         let botToken;
@@ -1069,7 +1103,15 @@ cli
                             }
                         }
                         // Fall back to first guild the bot is in
-                        const firstGuild = client.guilds.cache.first();
+                        let firstGuild = client.guilds.cache.first();
+                        if (!firstGuild) {
+                            // Cache might be empty, try fetching guilds from API
+                            const fetched = await client.guilds.fetch();
+                            const firstOAuth2Guild = fetched.first();
+                            if (firstOAuth2Guild) {
+                                firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                            }
+                        }
                         if (!firstGuild) {
                             throw new Error('No guild found. Add the bot to a server first.');
                         }
@@ -1092,18 +1134,12 @@ cli
             }
         }
         cliLogger.log('Fetching channel info...');
-        // Get channel info to extract directory from topic
-        const channelResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}`, {
-            headers: {
-                Authorization: `Bot ${botToken}`,
-            },
-        });
-        if (!channelResponse.ok) {
-            const error = await channelResponse.text();
-            cliLogger.log('Failed to fetch channel');
-            throw new Error(`Discord API error: ${channelResponse.status} - ${error}`);
+        if (!channelId) {
+            throw new Error('Channel ID not resolved');
         }
-        const channelData = (await channelResponse.json());
+        const rest = new REST().setToken(botToken);
+        // Get channel info to extract directory from topic
+        const channelData = (await rest.get(Routes.channel(channelId)));
         const channelConfig = await getChannelDirectory(channelData.id);
         if (!channelConfig) {
             cliLogger.log('Channel not configured');
@@ -1116,17 +1152,56 @@ cli
             cliLogger.log('Channel belongs to different bot');
             throw new Error(`Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`);
         }
+        // Resolve username to user ID if provided
+        const resolvedUser = await (async () => {
+            if (!options.user) {
+                return undefined;
+            }
+            cliLogger.log(`Searching for user "${options.user}" in guild...`);
+            const searchResults = (await rest.get(Routes.guildMembersSearch(channelData.guild_id), {
+                query: new URLSearchParams({ query: options.user, limit: '10' }),
+            }));
+            // Find exact match by display name, nickname, or username
+            const exactMatch = searchResults.find((member) => {
+                const displayName = member.nick || member.user.global_name || member.user.username;
+                return (displayName.toLowerCase() === options.user.toLowerCase() ||
+                    member.user.username.toLowerCase() === options.user.toLowerCase());
+            });
+            const member = exactMatch || searchResults[0];
+            if (!member) {
+                throw new Error(`User "${options.user}" not found in guild`);
+            }
+            const username = member.nick || member.user.global_name || member.user.username;
+            cliLogger.log(`Found user: ${username} (${member.user.id})`);
+            return { id: member.user.id, username };
+        })();
         cliLogger.log('Creating starter message...');
         // Discord has a 2000 character limit for messages.
         // If prompt exceeds this, send it as a file attachment instead.
         const DISCORD_MAX_LENGTH = 2000;
         let starterMessage;
+        // Compute thread name and worktree name early (needed for embed)
+        const baseThreadName = name || (prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt);
+        const worktreeName = options.worktree
+            ? formatWorktreeName(typeof options.worktree === 'string' ? options.worktree : baseThreadName)
+            : undefined;
+        const threadName = worktreeName
+            ? `${WORKTREE_PREFIX}${baseThreadName}`
+            : baseThreadName;
         // Embed marker for auto-start sessions (unless --notify-only)
-        // Bot checks for this embed footer to know it should start a session
-        const AUTO_START_MARKER = 'kimaki:start';
-        const autoStartEmbed = notifyOnly
+        // Bot parses this YAML to know it should start a session, optionally create a worktree, and set initial user
+        const embedMarker = notifyOnly
             ? undefined
-            : [{ color: 0x2b2d31, footer: { text: AUTO_START_MARKER } }];
+            : {
+                start: true,
+                ...(worktreeName && { worktree: worktreeName }),
+                ...(resolvedUser && { username: resolvedUser.username, userId: resolvedUser.id }),
+                ...(options.agent && { agent: options.agent }),
+                ...(options.model && { model: options.model }),
+            };
+        const autoStartEmbed = embedMarker
+            ? [{ color: 0x2b2d31, footer: { text: yaml.dump(embedMarker) } }]
+            : undefined;
         if (prompt.length > DISCORD_MAX_LENGTH) {
             // Send as file attachment with a short summary
             const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
@@ -1139,7 +1214,8 @@ cli
             const tmpFile = path.join(tmpDir, `prompt-${Date.now()}.md`);
             fs.writeFileSync(tmpFile, prompt);
             try {
-                // Create message with file attachment
+                // Using raw fetch for file uploads because discord.js REST client
+                // doesn't handle FormData/multipart file attachments correctly
                 const formData = new FormData();
                 formData.append('payload_json', JSON.stringify({
                     content: summaryContent,
@@ -1169,49 +1245,28 @@ cli
         }
         else {
             // Normal case: send prompt inline
-            const starterMessageResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bot ${botToken}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    content: prompt,
-                    embeds: autoStartEmbed,
-                }),
-            });
-            if (!starterMessageResponse.ok) {
-                const error = await starterMessageResponse.text();
-                cliLogger.log('Failed to create message');
-                throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
-            }
-            starterMessage = (await starterMessageResponse.json());
+            starterMessage = (await rest.post(Routes.channelMessages(channelId), {
+                body: { content: prompt, embeds: autoStartEmbed },
+            }));
         }
         cliLogger.log('Creating thread...');
-        // Create thread from the message
-        const threadName = name || (prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt);
-        const threadResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages/${starterMessage.id}/threads`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bot ${botToken}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
+        const threadData = (await rest.post(Routes.threads(channelId, starterMessage.id), {
+            body: {
                 name: threadName.slice(0, 100),
                 auto_archive_duration: 1440, // 1 day
-            }),
-        });
-        if (!threadResponse.ok) {
-            const error = await threadResponse.text();
-            cliLogger.log('Failed to create thread');
-            throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
-        }
-        const threadData = (await threadResponse.json());
+            },
+        }));
         cliLogger.log('Thread created!');
+        // Add user to thread if specified
+        if (resolvedUser) {
+            cliLogger.log(`Adding user ${resolvedUser.username} to thread...`);
+            await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id));
+        }
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
+        const worktreeNote = worktreeName ? `\nWorktree: ${worktreeName} (will be created by bot)` : '';
         const successMessage = notifyOnly
             ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
-            : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
+            : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}${worktreeNote}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
         note(successMessage, '✅ Thread Created');
         cliLogger.log(threadUrl);
         process.exit(0);
@@ -1311,7 +1366,15 @@ cli
                 }
                 catch (error) {
                     cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.message : String(error));
-                    const firstGuild = client.guilds.cache.first();
+                    let firstGuild = client.guilds.cache.first();
+                    if (!firstGuild) {
+                        // Cache might be empty, try fetching guilds from API
+                        const fetched = await client.guilds.fetch();
+                        const firstOAuth2Guild = fetched.first();
+                        if (firstOAuth2Guild) {
+                            firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                        }
+                    }
                     if (!firstGuild) {
                         cliLogger.log('No guild found');
                         cliLogger.error('No guild found. Add the bot to a server first.');
@@ -1322,7 +1385,15 @@ cli
                 }
             }
             else {
-                const firstGuild = client.guilds.cache.first();
+                let firstGuild = client.guilds.cache.first();
+                if (!firstGuild) {
+                    // Cache might be empty, try fetching guilds from API
+                    const fetched = await client.guilds.fetch();
+                    const firstOAuth2Guild = fetched.first();
+                    if (firstOAuth2Guild) {
+                        firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                    }
+                }
                 if (!firstGuild) {
                     cliLogger.log('No guild found');
                     cliLogger.error('No guild found. Add the bot to a server first.');

package/dist/commands/create-new-project.js

@@ -101,6 +101,7 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
             thread,
             projectDirectory,
             channelId: textChannel.id,
+            appId,
         });
         logger.log(`Created new project ${channelName} at ${projectDirectory}`);
     }

package/dist/commands/diff.js

@@ -0,0 +1,130 @@
+// /diff command - Show git diff as a shareable URL.
+import { ChannelType, EmbedBuilder } from 'discord.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const execAsync = promisify(exec);
+const logger = createLogger(LogPrefix.DIFF);
+export async function handleDiffCommand({ command }) {
+    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);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = isThread
+        ? await resolveTextChannel(channel)
+        : channel;
+    const { projectDirectory: directory } = await getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        const projectName = path.basename(directory);
+        const title = `${projectName}: Discord /diff`;
+        const { stdout, stderr } = await execAsync(`bunx critique --web "${title}" --json`, {
+            cwd: directory,
+            timeout: 30000,
+        });
+        // critique --json outputs JSON on the last line: {"url":"...","id":"..."} or {"error":"..."}
+        const output = stdout || stderr;
+        const lines = output.trim().split('\n');
+        const jsonLine = lines[lines.length - 1];
+        if (!jsonLine) {
+            await command.editReply({
+                content: 'No changes to show',
+            });
+            return;
+        }
+        let result;
+        try {
+            result = JSON.parse(jsonLine);
+        }
+        catch {
+            // Fallback: try to find URL in output
+            const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/);
+            if (urlMatch) {
+                await command.editReply({
+                    content: `[diff](${urlMatch[0]})`,
+                });
+                logger.log(`Diff shared: ${urlMatch[0]}`);
+                return;
+            }
+            await command.editReply({
+                content: 'No changes to show',
+            });
+            return;
+        }
+        if (result.error || !result.url || !result.id) {
+            await command.editReply({
+                content: result.error || 'No changes to show',
+            });
+            return;
+        }
+        const imageUrl = `https://critique.work/og/${result.id}.png`;
+        const embed = new EmbedBuilder().setTitle(title).setURL(result.url).setImage(imageUrl);
+        await command.editReply({
+            embeds: [embed],
+        });
+        logger.log(`Diff shared: ${result.url}`);
+    }
+    catch (error) {
+        logger.error('[DIFF] Error:', error);
+        // exec error includes stdout/stderr - try to parse JSON from it
+        const execError = error;
+        const output = execError.stdout || execError.stderr || '';
+        // Check if critique output JSON even on error
+        const lines = output.trim().split('\n');
+        const jsonLine = lines[lines.length - 1];
+        if (jsonLine) {
+            try {
+                const result = JSON.parse(jsonLine);
+                if (result.error) {
+                    await command.editReply({
+                        content: result.error,
+                    });
+                    return;
+                }
+            }
+            catch {
+                // not JSON, continue to generic error
+            }
+        }
+        // Check for common errors
+        const message = execError.message || 'Unknown error';
+        if (message.includes('command not found') || message.includes('ENOENT')) {
+            await command.editReply({
+                content: 'bunx/critique not available',
+            });
+            return;
+        }
+        await command.editReply({
+            content: `Failed to generate diff: ${message.slice(0, 200)}`,
+        });
+    }
+}

package/dist/commands/mention-mode.js

@@ -0,0 +1,51 @@
+// /toggle-mention-mode command.
+// Toggles mention-only mode for a channel.
+// When enabled, bot only responds to messages that @mention it.
+// Messages in threads are not affected - they always work without mentions.
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelMentionMode, setChannelMentionMode } from '../database.js';
+import { getKimakiMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const mentionModeLogger = createLogger(LogPrefix.CLI);
+/**
+ * Handle the /toggle-mention-mode slash command.
+ * Toggles whether the bot only responds when @mentioned in this channel.
+ */
+export async function handleToggleMentionModeCommand({ command, appId, }) {
+    mentionModeLogger.log('[TOGGLE_MENTION_MODE] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = await getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = await getChannelMentionMode(textChannel.id);
+    const nextEnabled = !wasEnabled;
+    await setChannelMentionMode(textChannel.id, nextEnabled);
+    const nextLabel = nextEnabled ? 'enabled' : 'disabled';
+    mentionModeLogger.log(`[TOGGLE_MENTION_MODE] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`);
+    await command.reply({
+        content: nextEnabled
+            ? `Mention mode **enabled** for this channel.\nThe bot will only start new sessions when @mentioned.\nMessages in existing threads are not affected.`
+            : `Mention mode **disabled** for this channel.\nThe bot will respond to all messages in **#${textChannel.name}**.`,
+        ephemeral: true,
+    });
+}