kimaki 0.19.0 → 0.20.1

package/dist/cli-commands/project.js

@@ -56,74 +56,7 @@ cli
         void client.login(botToken);
     });
     cliLogger.log('Finding guild...');
-    // Find guild
-    let guild;
-    if (options.guild) {
-        const guildId = String(options.guild);
-        const foundGuild = client.guilds.cache.get(guildId);
-        if (!foundGuild) {
-            cliLogger.log('Guild not found');
-            cliLogger.error(`Guild not found: ${guildId}`);
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = foundGuild;
-    }
-    else {
-        const existingChannelId = await (await getDb()).query.channel_directories.findFirst({
-            where: { channel_type: 'text' },
-            orderBy: { created_at: 'desc' },
-            columns: { channel_id: true },
-        }).then((row) => row?.channel_id);
-        if (existingChannelId) {
-            try {
-                const ch = await client.channels.fetch(existingChannelId);
-                if (ch && !ch.isDMBased()) {
-                    guild = ch.guild;
-                }
-                else {
-                    throw new Error('Channel has no guild');
-                }
-            }
-            catch (error) {
-                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.stack : String(error));
-                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.');
-                    void client.destroy();
-                    process.exit(EXIT_NO_RESTART);
-                }
-                guild = firstGuild;
-            }
-        }
-        else {
-            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.');
-                void client.destroy();
-                process.exit(EXIT_NO_RESTART);
-            }
-            guild = firstGuild;
-        }
-    }
+    const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
     // Check if channel already exists in this guild
     cliLogger.log('Checking for existing channel...');
     try {
@@ -353,25 +286,7 @@ cli
         client.once(Events.Error, reject);
         client.login(botToken).catch(reject);
     });
-    let guild;
-    if (options.guild) {
-        const found = client.guilds.cache.get(options.guild);
-        if (!found) {
-            cliLogger.error(`Guild not found: ${options.guild}`);
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = found;
-    }
-    else {
-        const first = client.guilds.cache.first();
-        if (!first) {
-            cliLogger.error('No guild found. Add the bot to a server first.');
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = first;
-    }
+    const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
     const { textChannelId, channelName } = await createProjectChannels({
         guild,
         projectDirectory,
@@ -383,4 +298,87 @@ cli
     cliLogger.log(channelUrl);
     process.exit(0);
 });
+// Resolve the guild for project add/create commands. In gateway mode the
+// guild cache only contains authorized guilds, so picking from cache is safe.
+// The old approach fetched an existing channel to infer the guild, but that
+// breaks when the channel belongs to a different guild (e.g. old self-hosted
+// bot channels) and the gateway proxy rejects the REST call. This led to a
+// non-deterministic fallback that picked the wrong guild.
+async function resolveGuildForProjectCommand({ client, guildIdOverride }) {
+    if (guildIdOverride) {
+        const found = client.guilds.cache.get(guildIdOverride);
+        if (!found) {
+            cliLogger.error(`Guild not found: ${guildIdOverride}`);
+            void client.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        return found;
+    }
+    // Try existing channel lookup to find the guild the user already has channels in.
+    // This handles multi-guild setups where we want to add to the same guild.
+    const db = await getDb();
+    const existingChannels = await db.query.channel_directories.findMany({
+        where: { channel_type: 'text' },
+        orderBy: { created_at: 'desc' },
+        columns: { channel_id: true },
+        limit: 20,
+    });
+    // Log available guilds for debugging guild selection issues
+    const cachedGuilds = Array.from(client.guilds.cache.values());
+    cliLogger.debug(`Guilds in cache (${cachedGuilds.length}): ${cachedGuilds.map((g) => `${g.name} (${g.id})`).join(', ')}`);
+    // When multiple guilds are available, find which guild has the most
+    // existing channels. The user's main guild will have far more channels
+    // than a test/demo guild.
+    const guildHits = new Map();
+    for (const row of existingChannels) {
+        try {
+            const ch = await client.channels.fetch(row.channel_id);
+            if (ch && !ch.isDMBased()) {
+                const entry = guildHits.get(ch.guild.id);
+                if (entry) {
+                    entry.count++;
+                }
+                else {
+                    guildHits.set(ch.guild.id, { guild: ch.guild, count: 1 });
+                }
+            }
+        }
+        catch {
+            // Channel might be in a different guild (gateway proxy rejects) or deleted, skip
+        }
+    }
+    if (guildHits.size > 0) {
+        // Pick the guild with the most channels
+        const best = Array.from(guildHits.values()).sort((a, b) => b.count - a.count)[0];
+        cliLogger.debug(`Guild channel counts: ${Array.from(guildHits.values()).map((e) => `${e.guild.name} (${e.guild.id}): ${e.count}`).join(', ')}`);
+        cliLogger.debug(`Selected guild: ${best.guild.name} (${best.guild.id}) with ${best.count} channels`);
+        return best.guild;
+    }
+    cliLogger.debug('Could not resolve guild from existing channels, falling back to cache');
+    // If only one guild in cache, use it directly (common case).
+    // If multiple guilds, error out and ask the user to specify --guild
+    // since we can't determine which one to use.
+    if (cachedGuilds.length === 1) {
+        return cachedGuilds[0];
+    }
+    if (cachedGuilds.length > 1) {
+        cliLogger.error(`Multiple guilds found. Use --guild to specify which one:\n${cachedGuilds.map((g) => `  ${g.id}  ${g.name}`).join('\n')}`);
+        void client.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Cache empty, try fetching
+    const fetched = await client.guilds.fetch();
+    if (fetched.size === 1) {
+        const firstOAuth2Guild = fetched.first();
+        return await client.guilds.fetch(firstOAuth2Guild.id);
+    }
+    if (fetched.size > 1) {
+        cliLogger.error(`Multiple guilds found. Use --guild to specify which one:\n${Array.from(fetched.values()).map((g) => `  ${g.id}  ${g.name}`).join('\n')}`);
+        void client.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    cliLogger.error('No guild found. Add the bot to a server first.');
+    void client.destroy();
+    process.exit(EXIT_NO_RESTART);
+}
 export default cli;

package/dist/commands/agent.js

@@ -4,12 +4,16 @@
 // the prompt is sent with that agent and the session keeps that agent afterwards.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
+import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, getChannelWorktreesEnabled, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, resolveWorkingDirectory, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentModelInfo } from './model.js';
+import { isGitRepositoryRoot } from '../worktrees.js';
+import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage, } from './new-worktree.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
+import { store } from '../store.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
 const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000;
 const pendingAgentContexts = new Map();
@@ -429,22 +433,65 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             return;
         }
         await command.deferReply();
+        // Check if worktrees should be enabled (CLI flag OR channel setting),
+        // mirroring the logic in discord-bot.ts message handler.
+        const wantsWorktrees = store.getState().useWorktrees ||
+            (await getChannelWorktreesEnabled(channel.id));
+        const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+        if (wantsWorktrees && !shouldUseWorktrees) {
+            agentLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+        }
+        const baseThreadName = prompt.slice(0, 80);
+        const threadName = shouldUseWorktrees
+            ? `${WORKTREE_PREFIX}${baseThreadName}`
+            : baseThreadName;
         const starterMessage = await channel.send({
             content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
-            name: prompt.slice(0, 80),
+            name: threadName.slice(0, 80),
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `${resolvedAgentName} agent prompt`,
         });
         await thread.members.add(command.user.id);
-        await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`);
+        // Create worktree in background if enabled, same as discord-bot.ts
+        let worktreePromise;
+        if (shouldUseWorktrees) {
+            const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50));
+            agentLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+            const worktreeStatusMessage = await thread
+                .send({
+                content: worktreeCreatingMessage(worktreeName),
+                flags: SILENT_MESSAGE_FLAGS,
+            })
+                .catch(() => undefined);
+            worktreePromise = createWorktreeInBackground({
+                thread,
+                starterMessage: worktreeStatusMessage,
+                worktreeName,
+                projectDirectory,
+                rest: command.client.rest,
+            });
+        }
+        const sessionDirectory = await (async () => {
+            if (!worktreePromise)
+                return projectDirectory;
+            const result = await worktreePromise;
+            if (result instanceof Error)
+                return projectDirectory;
+            return result;
+        })();
+        await command
+            .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
+            .catch(() => {
+            agentLogger.warn('[AGENT] Failed to edit quick-agent reply, continuing session');
+        });
         const runtime = getOrCreateRuntime({
             threadId: thread.id,
             thread,
             projectDirectory,
-            sdkDirectory: projectDirectory,
+            sdkDirectory: sessionDirectory,
             channelId: channel.id,
             appId,
         });

package/dist/commands/user-command.js

@@ -1,11 +1,14 @@
 // User-defined OpenCode command handler.
 // Handles slash commands that map to user-configured commands in opencode.json.
-import { ChannelType, MessageFlags, } from 'discord.js';
+import { ChannelType, MessageFlags, ThreadAutoArchiveDuration, } from 'discord.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { getChannelDirectory, getThreadSession } from '../database.js';
+import { getChannelDirectory, getChannelWorktreesEnabled, getThreadSession, } from '../database.js';
 import { store } from '../store.js';
+import { isGitRepositoryRoot } from '../worktrees.js';
+import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage, } from './new-worktree.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
 import fs from 'node:fs';
 const userCommandLogger = createLogger(LogPrefix.USER_CMD);
 const DISCORD_MESSAGE_LIMIT = 2000;
@@ -107,23 +110,62 @@ export const handleUserCommand = async ({ command, appId, }) => {
         }
         else if (textChannel) {
             // Running in text channel - create a new thread
+            // Check if worktrees should be enabled (CLI flag OR channel setting),
+            // mirroring the logic in discord-bot.ts message handler.
+            const wantsWorktrees = store.getState().useWorktrees ||
+                (await getChannelWorktreesEnabled(textChannel.id));
+            const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+            if (wantsWorktrees && !shouldUseWorktrees) {
+                userCommandLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+            }
+            const baseThreadName = commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT);
+            const threadName = shouldUseWorktrees
+                ? `${WORKTREE_PREFIX}${baseThreadName}`
+                : baseThreadName;
             const starterMessage = await textChannel.send({
                 content: threadOpeningMessage,
                 flags: SILENT_MESSAGE_FLAGS,
             });
             const newThread = await starterMessage.startThread({
-                name: commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT),
-                autoArchiveDuration: 1440,
+                name: threadName.slice(0, DISCORD_THREAD_NAME_LIMIT),
+                autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
                 reason: `OpenCode command: ${commandName}`,
             });
             // Add user to thread so it appears in their sidebar
             await newThread.members.add(command.user.id);
+            // Create worktree in background if enabled, same as discord-bot.ts
+            let worktreePromise;
+            if (shouldUseWorktrees) {
+                const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50));
+                userCommandLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+                const worktreeStatusMessage = await newThread
+                    .send({
+                    content: worktreeCreatingMessage(worktreeName),
+                    flags: SILENT_MESSAGE_FLAGS,
+                })
+                    .catch(() => undefined);
+                worktreePromise = createWorktreeInBackground({
+                    thread: newThread,
+                    starterMessage: worktreeStatusMessage,
+                    worktreeName,
+                    projectDirectory,
+                    rest: command.client.rest,
+                });
+            }
+            const sessionDirectory = await (async () => {
+                if (!worktreePromise)
+                    return projectDirectory;
+                const result = await worktreePromise;
+                if (result instanceof Error)
+                    return projectDirectory;
+                return result;
+            })();
             await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
             const runtime = getOrCreateRuntime({
                 threadId: newThread.id,
                 thread: newThread,
                 projectDirectory,
-                sdkDirectory: projectDirectory,
+                sdkDirectory: sessionDirectory,
                 channelId: textChannel.id,
                 appId,
             });

package/dist/discord-bot.js

@@ -173,6 +173,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     if (!discordClient) {
         discordClient = await createDiscordClient();
     }
+    store.setState({ useWorktrees: Boolean(useWorktrees) });
     let currentAppId = appId;
     const setupHandlers = async (c) => {
         discordLogger.log(`Discord bot logged in as ${c.user.tag}`);
@@ -260,9 +261,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordLogger.warn(`[GATEWAY] Shard ${shardId} reconnecting: ${parts.join(', ')}`);
         if (state.attempts >= MAX_RECONNECT_ATTEMPTS) {
             discordLogger.error(`[GATEWAY] Shard ${shardId} exceeded ${MAX_RECONNECT_ATTEMPTS} reconnect attempts, self-restarting`);
-            // Self-restart: cleanup then spawn a fresh process. This works whether
-            // the bin.ts wrapper is present or not (unlike process.exit(1) which
-            // only restarts when the wrapper is the parent).
+            // Self-restart: cleanup, then exit non-zero so the bin.ts wrapper
+            // restarts us. Without the wrapper this exits after logging a warning.
             void selfRestart('gateway-reconnect-limit');
         }
     });
@@ -332,15 +332,13 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     return;
                 }
             }
-            // Ignore messages that start with a mention of another user (not the bot).
-            // These are likely users talking to each other, not the bot.
+            // Detect messages that start with a mention of another user (not the bot).
+            // In channels these are fully ignored. In threads they are added to the
+            // session context without triggering the AI (noReply), so the agent sees
+            // user-to-user conversation on the next real turn.
             const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/);
-            if (leadingMentionMatch) {
-                const mentionedUserId = leadingMentionMatch[1];
-                if (mentionedUserId !== discordClient.user?.id) {
-                    return;
-                }
-            }
+            const isLeadingMentionToOtherUser = leadingMentionMatch &&
+                leadingMentionMatch[1] !== discordClient.user?.id;
             if (message.partial) {
                 discordLogger.log(`Fetching partial message ${message.id}`);
                 const fetched = await message.fetch()
@@ -354,6 +352,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             // When mention mode is enabled, users without Kimaki role can message
             // without getting a permission error - we just silently ignore.
             const channel = message.channel;
+            // In text channels, messages starting with a mention to another user
+            // are fully ignored before any permission or mention-mode checks.
+            // This prevents permission-error replies for user-to-user conversation.
+            if (channel.type === ChannelType.GuildText && isLeadingMentionToOtherUser) {
+                return;
+            }
             if (channel.type === ChannelType.GuildText && !isCliInjectedPrompt) {
                 const mentionModeEnabled = await getChannelMentionMode(channel.id);
                 if (mentionModeEnabled) {
@@ -435,6 +439,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     discordLogger.log(`Ignoring thread ${thread.id}: no existing session and bot not mentioned`);
                     return;
                 }
+                // Context-only messages (user-to-user replies) can't be stored without
+                // an existing session. Skip early to avoid creating a runtime or running
+                // preprocessing for nothing.
+                if (isLeadingMentionToOtherUser && !hasExistingSession) {
+                    return;
+                }
                 const parent = thread.parent;
                 let projectDirectory;
                 if (parent) {
@@ -509,7 +519,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
                     ? extractBtwSuffix(message.content || '')
                     : null;
-                if (btwResult?.forceBtw && projectDirectory) {
+                if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
                     const result = await forkSessionToBtwThread({
                         sourceThread: thread,
                         projectDirectory,
@@ -559,7 +569,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     appId: currentAppId,
                 });
                 // Cancel interactive UI when a real user sends a message.
-                if (!message.author.bot && !isCliInjectedPrompt) {
+                // Context-only messages (user-to-user replies) should not interrupt
+                // the active run or dismiss pending UI.
+                if (!message.author.bot && !isCliInjectedPrompt && !isLeadingMentionToOtherUser) {
                     cancelPendingActionButtons(thread.id);
                     cancelHtmlActionsForThread(thread.id);
                     const dismissedPermission = await cancelPendingPermission(thread.id);
@@ -594,6 +606,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                    noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,
@@ -1152,7 +1165,13 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
         });
     });
-    // Self-restart: prefer bin.ts wrapper (keeps Ctrl+C), fall back to detached spawn.
+    // Self-restart: exit with code 1 so the bin.ts wrapper restarts us with
+    // exponential backoff and crash-loop detection. When running without the
+    // wrapper (e.g. `tsx src/cli.ts`), the process just exits and the user
+    // sees the non-zero exit code — they should use `tsx src/bin.ts` instead
+    // for auto-restart support. The previous detached-spawn fallback was
+    // unreliable: process.exit(0) could kill the child before it started,
+    // there was no backoff between restarts, and spawn failures were silent.
     let selfRestarting = false;
     async function selfRestart(reason) {
         if (selfRestarting) {
@@ -1167,20 +1186,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         catch (error) {
             voiceLogger.error(`[${reason}] Error during shutdown:`, error);
         }
-        if (process.env.__KIMAKI_CHILD) {
-            discordLogger.log('Wrapper detected, exiting for wrapper restart');
-            process.exit(1);
+        if (!process.env.__KIMAKI_CHILD) {
+            discordLogger.warn('No restart wrapper detected. Run via `tsx src/bin.ts` (dev) or `kimaki` (npm) for auto-restart on crash.');
         }
-        const { spawn } = await import('node:child_process');
-        const env = { ...process.env };
-        delete env.__KIMAKI_CHILD;
-        spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
-            stdio: 'inherit',
-            detached: true,
-            cwd: process.cwd(),
-            env,
-        }).unref();
-        process.exit(0);
+        process.exit(1);
     }
     process.on('SIGUSR2', () => {
         discordLogger.log('Received SIGUSR2, restarting after cleanup...');

package/dist/discord-utils.js

@@ -590,14 +590,31 @@ export async function resolveWorkingDirectory({ channel, }) {
         workingDirectory,
     };
 }
+// Discord upload size limits per server boost tier (bytes).
+// Bots default to 25 MB; boosted servers raise the ceiling.
+export const DISCORD_DEFAULT_MAX_FILE_SIZE = 25 * 1024 * 1024;
 /**
  * Upload files to a Discord thread/channel in a single message.
  * Sending all files in one message causes Discord to display images in a grid layout.
+ *
+ * Files are validated against the Discord upload size limit before reading them
+ * into memory. Pass `maxFileSize` if you know the guild's boost tier limit;
+ * otherwise the conservative 25 MB bot default is used.
  */
-export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+export async function uploadFilesToDiscord({ threadId, botToken, files, maxFileSize = DISCORD_DEFAULT_MAX_FILE_SIZE, }) {
     if (files.length === 0) {
         return;
     }
+    // Fail fast: check file sizes before reading anything into memory
+    const sizeLimit = maxFileSize ?? DISCORD_DEFAULT_MAX_FILE_SIZE;
+    for (const file of files) {
+        const stat = fs.statSync(file);
+        if (stat.size > sizeLimit) {
+            const fileMB = (stat.size / 1024 / 1024).toFixed(1);
+            const limitMB = (sizeLimit / 1024 / 1024).toFixed(0);
+            throw new Error(`File "${path.basename(file)}" is ${fileMB} MB, which exceeds Discord's ${limitMB} MB upload limit`);
+        }
+    }
     // Build attachments array for all files
     const attachments = files.map((file, index) => ({
         id: index,

package/dist/message-formatting.js

@@ -266,6 +266,44 @@ export async function getFileAttachments(message) {
     return results.filter((r) => r !== null);
 }
 const MAX_BASH_COMMAND_INLINE_LENGTH = 100;
+/**
+ * Format the inline title for a bash tool part. Handles three cases:
+ * 1. Short single-line command → show full command
+ * 2. Long/multiline command with description → show description
+ * 3. Long/multiline command without description → truncate first line of command
+ *
+ * The description field was removed from the opencode v2 bash tool schema but
+ * kimaki's system prompt instructs models to always send it as an extra field.
+ * Case 3 is the fallback when a model omits it.
+ */
+export function formatBashToolTitle({ command, description, stateTitle, }) {
+    if (!command && !description && !stateTitle)
+        return '';
+    const isSingleLine = !command.includes('\n');
+    // Find first non-empty line to handle commands with leading blank lines
+    const firstMeaningfulLine = command
+        .split('\n')
+        .find((line) => line.trim().length > 0)
+        ?.trimStart() ?? '';
+    if (command && isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH) {
+        return ` _${escapeInlineMarkdown(command)}_`;
+    }
+    if (description) {
+        return ` _${escapeInlineMarkdown(description)}_`;
+    }
+    if (firstMeaningfulLine.length > 0) {
+        const needsTruncation = firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH;
+        const base = needsTruncation
+            ? firstMeaningfulLine.slice(0, MAX_BASH_COMMAND_INLINE_LENGTH)
+            : firstMeaningfulLine;
+        // Always add ellipsis when showing a partial command (multiline or length-truncated)
+        return ` _${escapeInlineMarkdown(base)}…_`;
+    }
+    if (stateTitle) {
+        return ` _${escapeInlineMarkdown(stateTitle)}_`;
+    }
+    return '';
+}
 export function getToolSummaryText(part) {
     if (part.type !== 'tool')
         return '';
@@ -449,12 +487,10 @@ export function formatPart(part, prefix) {
             }
             const command = part.state.input?.command || '';
             const description = part.state.input?.description || '';
-            const isSingleLine = !command.includes('\n');
-            const toolTitle = isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH
-                ? ` _${escapeInlineMarkdown(command)}_`
-                : description
-                    ? ` _${escapeInlineMarkdown(description)}_`
-                    : '';
+            const toolTitle = formatBashToolTitle({
+                command,
+                description,
+            });
             return `┣ ${pfx}bash${toolTitle}`;
         }
         const summaryText = getToolSummaryText(part);
@@ -466,16 +502,12 @@ export function formatPart(part, prefix) {
         else if (part.tool === 'bash') {
             const command = part.state.input?.command || '';
             const description = part.state.input?.description || '';
-            const isSingleLine = !command.includes('\n');
-            if (isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH) {
-                toolTitle = `_${escapeInlineMarkdown(command)}_`;
-            }
-            else if (description) {
-                toolTitle = `_${escapeInlineMarkdown(description)}_`;
-            }
-            else if (stateTitle) {
-                toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;
-            }
+            const formatted = formatBashToolTitle({
+                command,
+                description,
+                stateTitle,
+            });
+            toolTitle = formatted.startsWith(' ') ? formatted.slice(1) : formatted;
         }
         else if (stateTitle) {
             toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;

package/dist/message-formatting.test.js

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'vitest';
-import { formatPart, formatTodoList, serializeEmbeds, serializePoll, serializeMessageSnapshots } from './message-formatting.js';
+import { formatBashToolTitle, formatPart, formatTodoList, serializeEmbeds, serializePoll, serializeMessageSnapshots } from './message-formatting.js';
 describe('formatPart', () => {
     test('callout text does not get ⬥ prefix', () => {
         const part = {
@@ -42,6 +42,44 @@ describe('formatPart', () => {
     `);
     });
 });
+describe('formatBashToolTitle', () => {
+    test('short single-line command shown in full', () => {
+        expect(formatBashToolTitle({ command: 'echo hello' })).toMatchInlineSnapshot(`" _echo hello_"`);
+    });
+    test('multiline command without description truncates to first line', () => {
+        expect(formatBashToolTitle({ command: 'echo hello\necho world\necho done' })).toMatchInlineSnapshot(`" _echo hello…_"`);
+    });
+    test('long single-line command is truncated with ellipsis', () => {
+        const longCommand = 'a'.repeat(150);
+        const result = formatBashToolTitle({ command: longCommand });
+        expect(result).toContain('…');
+        expect(result.length).toBeLessThan(150);
+    });
+    test('description is preferred over truncated command when present', () => {
+        expect(formatBashToolTitle({
+            command: 'echo hello\necho world',
+            description: 'Print greeting',
+        })).toMatchInlineSnapshot(`" _Print greeting_"`);
+    });
+    test('stateTitle used as last resort', () => {
+        expect(formatBashToolTitle({ command: '', stateTitle: 'Running tests' })).toMatchInlineSnapshot(`" _Running tests_"`);
+    });
+    test('empty inputs return empty string', () => {
+        expect(formatBashToolTitle({ command: '' })).toBe('');
+    });
+    test('leading blank line skipped, uses first meaningful line', () => {
+        expect(formatBashToolTitle({ command: '\npnpm test\npnpm build' })).toMatchInlineSnapshot(`" _pnpm test…_"`);
+    });
+    test('whitespace-only first line skipped', () => {
+        expect(formatBashToolTitle({ command: '   \npnpm test' })).toMatchInlineSnapshot(`" _pnpm test…_"`);
+    });
+    test('no description field (new opencode) with multiline command', () => {
+        // This is the exact scenario that was broken: opencode removed `description`
+        // from the bash tool schema, so multiline commands rendered as just "┣ bash"
+        const command = 'git diff HEAD~1 --stat && git log --oneline -5';
+        expect(formatBashToolTitle({ command: command + '\n' + 'echo done' })).toMatchInlineSnapshot(`" _git diff HEAD\\~1 --stat && git log --oneline -5…_"`);
+    });
+});
 describe('formatTodoList', () => {
     test('formats active todo with monospace numbers', () => {
         const part = {