kimaki 0.19.0 → 0.20.0

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/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}`);
@@ -332,15 +333,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 +353,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 +440,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 +520,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 +570,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 +607,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                    noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,

package/dist/message-formatting.js

@@ -266,6 +266,42 @@ 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 bash tool schema in newer opencode
+ * versions, so case 3 is the common path now. Without this fallback, long commands
+ * would render as just "┣ bash" with no context.
+ */
+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 truncated = firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH
+            ? firstMeaningfulLine.slice(0, MAX_BASH_COMMAND_INLINE_LENGTH) + '…'
+            : firstMeaningfulLine;
+        return ` _${escapeInlineMarkdown(truncated)}_`;
+    }
+    if (stateTitle) {
+        return ` _${escapeInlineMarkdown(stateTitle)}_`;
+    }
+    return '';
+}
 export function getToolSummaryText(part) {
     if (part.type !== 'tool')
         return '';
@@ -449,12 +485,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 +500,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 = {

package/dist/session-handler/thread-session-runtime.js

@@ -190,23 +190,23 @@ function getTokenTotal(tokens) {
         tokens.cache.read +
         tokens.cache.write);
 }
+/**
+ * Built-in read-only tools that are hidden in default verbosity mode.
+ * Any tool NOT in this list is considered "essential" and shown,
+ * which means custom tools, MCP tools, and plugin tools are visible by default.
+ */
+const HIDDEN_READONLY_TOOLS = [
+    'read',
+    'glob',
+    'grep',
+    'describe-media',
+    'todoread',
+];
 /** Check if a tool part is "essential" (shown in text-and-essential-tools mode). */
 export function isEssentialToolName(toolName) {
-    const essentialTools = [
-        'edit',
-        'write',
-        'apply_patch',
-        'bash',
-        'webfetch',
-        'websearch',
-        'googlesearch',
-        'codesearch',
-        'task',
-        'todowrite',
-        'skill',
-    ];
-    // Also match any MCP tool that contains these names
-    return essentialTools.some((name) => {
+    // Hide known read-only built-in tools; show everything else
+    // (custom tools, MCP tools, plugin tools are visible by default)
+    return !HIDDEN_READONLY_TOOLS.some((name) => {
         return toolName === name || toolName.endsWith(`_${name}`);
     });
 }
@@ -2062,6 +2062,15 @@ export class ThreadSessionRuntime {
                 skippedBySessionGuard = true;
                 return;
             }
+            // Context-only messages (noReply) should not create a new session.
+            // If there is no existing session, silently skip.
+            if (input.noReply) {
+                const existingSessionId = this.state?.sessionId || await getThreadSession(this.thread.id) || undefined;
+                if (!existingSessionId) {
+                    logger.log(`[INGRESS] Skipping noReply message for thread ${this.threadId}: no existing session`);
+                    return;
+                }
+            }
             // Helper: stop typing and drain queued local messages on error.
             const cleanupOnError = async (errorMessage) => {
                 this.stopTyping();
@@ -2269,6 +2278,7 @@ export class ThreadSessionRuntime {
                 ...(resolvedAgent ? { agent: resolvedAgent } : {}),
                 ...(modelField ? { model: modelField } : {}),
                 ...variantField,
+                ...(input.noReply ? { noReply: true } : {}),
             };
             const promptResult = await getClient().session.promptAsync(request)
                 .catch((e) => new OpenCodeSdkError({ operation: 'session.promptAsync', cause: e }));
@@ -2284,7 +2294,10 @@ export class ThreadSessionRuntime {
                 return;
             }
             logger.log(`[INGRESS] promptAsync accepted by opencode queue sessionId=${session.id} threadId=${this.threadId}`);
-            this.markQueueDispatchBusy(session.id);
+            // noReply messages don't trigger the agent loop, so don't mark as busy
+            if (!input.noReply) {
+                this.markQueueDispatchBusy(session.id);
+            }
         });
         if (skippedBySessionGuard) {
             return { queued: false };
@@ -2426,9 +2439,17 @@ export class ThreadSessionRuntime {
                 // Route with the resolved mode through normal paths.
                 // Await the enqueue so session state (ensureSession, setThreadSession)
                 // is persisted before the next message's preprocessing reads it.
-                const enqueueResult = resolvedInput.mode === 'local-queue' || resolvedInput.command
-                    ? await this.enqueueViaLocalQueue(resolvedInput)
-                    : await this.submitViaOpencodeQueue(resolvedInput);
+                // noReply messages always go through the opencode path so the flag
+                // reaches promptAsync; local queue doesn't support noReply.
+                const enqueueResult = resolvedInput.noReply
+                    ? await this.submitViaOpencodeQueue({
+                        ...resolvedInput,
+                        mode: 'opencode',
+                        command: undefined,
+                    })
+                    : (resolvedInput.mode === 'local-queue' || resolvedInput.command)
+                        ? await this.enqueueViaLocalQueue(resolvedInput)
+                        : await this.submitViaOpencodeQueue(resolvedInput);
                 resolveOuter(enqueueResult);
             }
             catch (err) {

package/dist/store.js

@@ -14,6 +14,7 @@ export const store = createStore(() => ({
     allowedMentions: ['users'],
     allowAllUsers: false,
     permissionTimeoutMs: 10 * 60 * 1000,
+    useWorktrees: false,
     autoUpgradeEnabled: true,
     syncEnabled: true,
     discordBaseUrl: 'https://discord.com',

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -25,8 +25,8 @@
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.0",
-    "opencode-cached-provider": "^0.0.1",
     "opencode-deterministic-provider": "^0.0.1",
+    "opencode-cached-provider": "^0.0.1",
     "db": "^0.0.0"
   },
   "dependencies": {
@@ -62,9 +62,9 @@
     "yaml": "^2.8.3",
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
-    "errore": "^0.14.1",
     "libsqlproxy": "^0.1.0",
     "opencode-injection-guard": "^0.2.1",
+    "errore": "^0.14.1",
     "traforo": "^0.7.1"
   },
   "optionalDependencies": {

package/skills/goke/SKILL.md

@@ -178,6 +178,23 @@ import { openInBrowser } from 'goke'
 await openInBrowser('https://example.com/dashboard')
 ```
 
+## Command Descriptions and Examples
+
+**Use backtick formatting in descriptions** for flags and command references (e.g. `` `--status` ``, `` `mycli deploy` ``). Plain text flag names won't render as code in generated docs.
+
+**Use `.example()` for usage examples, not the description string.** `generateDocs()` auto-wraps `.example()` strings in fenced `` ```sh `` code blocks. Examples in the description render as plain text without syntax highlighting.
+
+```ts
+cli.command(
+  'query <sql>',
+  dedent`
+    Run a SQL query. Add \`--json\` for the raw JSON envelope.
+  `,
+)
+  .example('mycli query "SELECT * FROM users" -p my-app')
+  .example('mycli query "SELECT * FROM users FORMAT CSV" > out.csv')
+```
+
 ## Command Naming Conventions
 
 **ALWAYS read existing commands before adding a new one.** Scan the CLI for option names, verbs, and noun patterns already in use. New commands must stay consistent with what exists.