kimaki 0.20.1 → 0.22.0

package/dist/commands/session.js

@@ -1,10 +1,13 @@
 // /new-session command - Start a new OpenCode session.
+// Works in both text channels and threads. When used in a thread, the new
+// session inherits the same working directory (worktree/workspace) so the
+// user stays in the same folder context.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory } from '../database.js';
+import { getChannelDirectory, getThreadWorktreeOrWorkspace, createPendingWorkspace, setWorkspaceReady, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
+import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete, resolveWorkingDirectory, resolveTextChannel, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -15,15 +18,50 @@ export async function handleSessionCommand({ command, appId, }) {
     const filesString = command.options.getString('files') || '';
     const agent = command.options.getString('agent') || undefined;
     const channel = command.channel;
-    if (!channel || channel.type !== ChannelType.GuildText) {
-        await command.editReply('This command can only be used in text channels');
+    const isThread = channel && [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+    ].includes(channel.type);
+    if (!channel || (channel.type !== ChannelType.GuildText && !isThread)) {
+        await command.editReply('This command can only be used in text channels or threads');
         return;
     }
-    const channelConfig = await getChannelDirectory(channel.id);
-    const projectDirectory = channelConfig?.directory;
-    if (!projectDirectory) {
-        await command.editReply('This channel is not configured with a project directory');
-        return;
+    // Resolve project and working directories.
+    // In a thread: inherit from the thread's session (worktree/workspace aware).
+    // In a text channel: look up the channel's configured directory.
+    let projectDirectory;
+    let sdkDirectory;
+    let textChannel;
+    let sourceWorkspace;
+    if (isThread) {
+        const threadChannel = channel;
+        const [resolved, parentChannel, workspace] = await Promise.all([
+            resolveWorkingDirectory({ channel: threadChannel }),
+            resolveTextChannel(threadChannel),
+            getThreadWorktreeOrWorkspace(threadChannel.id),
+        ]);
+        if (!resolved) {
+            await command.editReply('Could not determine project directory for this thread');
+            return;
+        }
+        if (!parentChannel) {
+            await command.editReply('Could not resolve parent text channel');
+            return;
+        }
+        projectDirectory = resolved.projectDirectory;
+        sdkDirectory = resolved.workingDirectory;
+        textChannel = parentChannel;
+        sourceWorkspace = workspace;
+    }
+    else {
+        const channelConfig = await getChannelDirectory(channel.id);
+        if (!channelConfig?.directory) {
+            await command.editReply('This channel is not configured with a project directory');
+            return;
+        }
+        projectDirectory = channelConfig.directory;
+        sdkDirectory = channelConfig.directory;
+        textChannel = channel;
     }
     if (!fs.existsSync(projectDirectory)) {
         await command.editReply(`Directory does not exist: ${projectDirectory}`);
@@ -43,8 +81,8 @@ export async function handleSessionCommand({ command, appId, }) {
         if (files.length > 0) {
             fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
         }
-        const starterMessage = await channel.send({
-            content: `🚀 **Starting OpenCode session**\n📝 ${prompt}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+        const starterMessage = await textChannel.send({
+            content: `**Starting OpenCode session**\n${prompt}${files.length > 0 ? `\nFiles: ${files.join(', ')}` : ''}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
@@ -52,6 +90,21 @@ export async function handleSessionCommand({ command, appId, }) {
             autoArchiveDuration: 1440,
             reason: 'OpenCode session',
         });
+        // Persist workspace association so commands in the new thread resolve the
+        // correct working directory, and the runtime survives bot restarts.
+        if (sourceWorkspace?.status === 'ready' && sourceWorkspace.workspace_directory) {
+            await createPendingWorkspace({
+                threadId: thread.id,
+                workspaceType: sourceWorkspace.workspace_type,
+                workspaceName: sourceWorkspace.workspace_name ?? '',
+                projectDirectory,
+            });
+            await setWorkspaceReady({
+                threadId: thread.id,
+                workspaceId: sourceWorkspace.workspace_id ?? undefined,
+                workspaceDirectory: sourceWorkspace.workspace_directory,
+            });
+        }
         // Add user to thread so it appears in their sidebar
         await thread.members.add(command.user.id);
         await command.editReply(`Created new session in ${thread.toString()}`);
@@ -59,8 +112,8 @@ export async function handleSessionCommand({ command, appId, }) {
             threadId: thread.id,
             thread,
             projectDirectory,
-            sdkDirectory: projectDirectory,
-            channelId: channel.id,
+            sdkDirectory,
+            channelId: textChannel.id,
             appId,
         });
         await runtime.enqueueIncoming({

package/dist/commands/tasks.js

@@ -1,10 +1,11 @@
 // /tasks command — list all scheduled tasks sorted by next run time.
 // Renders a markdown table that the CV2 pipeline auto-formats for Discord,
-// including HTML-backed action buttons for cancellable tasks.
+// including HTML-backed Run now / Delete action buttons.
 import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
 import { cancelScheduledTask, listScheduledTasks, } from '../database.js';
 import { splitTablesFromMarkdown } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import { runScheduledTaskNow } from '../task-runner.js';
 import { formatTimeAgo } from './worktrees.js';
 function formatTimeUntil(date) {
     const diffMs = date.getTime() - Date.now();
@@ -34,6 +35,9 @@ function scheduleLabel(task) {
     }
     return 'one-time';
 }
+function canRunTask(task) {
+    return task.status === 'planned';
+}
 function canCancelTask(task) {
     return task.status === 'planned' || task.status === 'running';
 }
@@ -42,25 +46,35 @@ function canCancelTask(task) {
 function sanitizeTableCell(value) {
     return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
 }
-function buildCancelButtonHtml({ buttonId }) {
-    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+function buildRunCell(task) {
+    if (!canRunTask(task)) {
+        return '-';
+    }
+    return `<button id="run-task-${task.id}" variant="primary">Run now</button>`;
 }
-function buildActionCell(task) {
+function buildCancelCell(task) {
     if (!canCancelTask(task)) {
         return '-';
     }
-    return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` });
+    return `<button id="cancel-task-${task.id}" variant="secondary">Delete</button>`;
 }
 // Cap rows to avoid exceeding Discord's 40-component CV2 limit.
-// Each cancellable row renders as text + action row + button (~4 components),
-// so 10 rows is a safe ceiling.
-const MAX_TASK_ROWS = 10;
+// Each actionable row is text + action row + up to 2 buttons (~4 components),
+// so 7 rows stays under the budget with separators.
+const MAX_TASK_ROWS = 7;
+function formatChannelCell(task) {
+    if (!task.channel_id) {
+        return '-';
+    }
+    return `<#${task.channel_id}>`;
+}
 function buildTaskTable({ tasks, }) {
-    const header = '| ID | Status | Prompt | Schedule | Next Run | Action |';
-    const separator = '|---|---|---|---|---|---|';
+    const header = '| ID | Status | Channel | Prompt | Schedule | Next Run | Run | Delete |';
+    const separator = '|---|---|---|---|---|---|---|---|';
     const rows = tasks.map((task) => {
         const id = String(task.id);
         const status = task.status;
+        const channel = formatChannelCell(task);
         const prompt = sanitizeTableCell(task.prompt_preview.length > 240
             ? task.prompt_preview.slice(0, 237) + '...'
             : task.prompt_preview);
@@ -73,8 +87,9 @@ function buildTaskTable({ tasks, }) {
             }
             return formatTimeUntil(task.next_run_at);
         })();
-        const action = buildActionCell(task);
-        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`;
+        const run = buildRunCell(task);
+        const cancel = buildCancelCell(task);
+        return `| ${id} | ${status} | ${channel} | ${prompt} | ${schedule} | ${nextRun} | ${run} | ${cancel} |`;
     });
     return [header, separator, ...rows].join('\n');
 }
@@ -107,12 +122,15 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`kimaki task list\` for full list.`
         : undefined;
     const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n');
+    const runnableTasksByButtonId = new Map();
     const cancellableTasksByButtonId = new Map();
     tasks.forEach((task) => {
-        if (!canCancelTask(task)) {
-            return;
+        if (canRunTask(task)) {
+            runnableTasksByButtonId.set(`run-task-${task.id}`, task);
+        }
+        if (canCancelTask(task)) {
+            cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
         }
-        cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
     });
     const tableMarkdown = buildTaskTable({ tasks });
     const markdown = combinedNotice
@@ -120,17 +138,32 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         : tableMarkdown;
     const segments = splitTablesFromMarkdown(markdown, {
         resolveButtonCustomId: ({ button }) => {
-            const task = cancellableTasksByButtonId.get(button.id);
-            if (!task) {
+            const runTask = runnableTasksByButtonId.get(button.id);
+            if (runTask) {
+                const actionId = registerHtmlAction({
+                    ownerKey,
+                    threadId: String(runTask.id),
+                    run: async ({ interaction }) => {
+                        await handleRunTaskAction({
+                            interaction,
+                            taskId: runTask.id,
+                            showAll,
+                        });
+                    },
+                });
+                return buildHtmlActionCustomId(actionId);
+            }
+            const cancelTask = cancellableTasksByButtonId.get(button.id);
+            if (!cancelTask) {
                 return new Error(`No task registered for button ${button.id}`);
             }
             const actionId = registerHtmlAction({
                 ownerKey,
-                threadId: String(task.id),
+                threadId: String(cancelTask.id),
                 run: async ({ interaction }) => {
                     await handleCancelTaskAction({
                         interaction,
-                        taskId: task.id,
+                        taskId: cancelTask.id,
                         showAll,
                     });
                 },
@@ -153,6 +186,58 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         flags: MessageFlags.IsComponentsV2,
     });
 }
+async function handleRunTaskAction({ interaction, taskId, showAll, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const token = interaction.client.token;
+    if (!token) {
+        await renderTasksReply({
+            guildId,
+            userId: interaction.user.id,
+            channelId: interaction.channelId,
+            showAll,
+            notice: `Could not run task #${taskId}: bot token unavailable.`,
+            editReply: (options) => {
+                return interaction.editReply(options);
+            },
+        });
+        return;
+    }
+    const result = await runScheduledTaskNow({ token, taskId });
+    const notice = (() => {
+        if (result instanceof Error) {
+            return `Could not run task #${taskId}: ${result.message}`;
+        }
+        if (result.kind === 'skipped') {
+            return `Task #${taskId} is already running or was claimed elsewhere.`;
+        }
+        if (result.kind === 'failed') {
+            return `Task #${taskId} failed: ${result.error.message}`;
+        }
+        return `Started task #${taskId}.`;
+    })();
+    await renderTasksReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        showAll,
+        notice,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
 async function handleCancelTaskAction({ interaction, taskId, showAll, }) {
     const guildId = interaction.guildId;
     if (!guildId) {

package/dist/commands/user-command.js

@@ -2,7 +2,7 @@
 // Handles slash commands that map to user-configured commands in opencode.json.
 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 { SILENT_MESSAGE_FLAGS, resolveWorkingDirectory } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getChannelDirectory, getChannelWorktreesEnabled, getThreadSession, } from '../database.js';
 import { store } from '../store.js';
@@ -91,11 +91,12 @@ export const handleUserCommand = async ({ command, appId, }) => {
         if (isThread && thread) {
             // Running in existing thread - just send the command
             await command.editReply(`Running ${commandInvocation}...`);
+            const resolved = await resolveWorkingDirectory({ channel: thread });
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
                 projectDirectory,
-                sdkDirectory: projectDirectory,
+                sdkDirectory: resolved?.workingDirectory || projectDirectory,
                 channelId: textChannel?.id,
                 appId,
             });

package/dist/database.js

@@ -380,6 +380,20 @@ export async function upsertThreadSession({ threadId, sessionId, source }) {
         .values({ thread_id: threadId, session_id: sessionId, source })
         .onConflictDoUpdate({ target: schema.thread_sessions.thread_id, set: { session_id: sessionId, source } });
 }
+export async function getThreadParentSessionId(threadId) {
+    const db = await getDb();
+    return (await db.query.thread_sessions.findFirst({
+        where: { thread_id: threadId },
+        columns: { parent_session_id: true },
+    }))?.parent_session_id ?? undefined;
+}
+export async function setThreadParentSessionId({ threadId, parentSessionId, }) {
+    const db = await getDb();
+    await db
+        .update(schema.thread_sessions)
+        .set({ parent_session_id: parentSessionId })
+        .where(orm.eq(schema.thread_sessions.thread_id, threadId));
+}
 export async function getThreadSessionSource(threadId) {
     const db = await getDb();
     return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId }, columns: { source: true } }))?.source;

package/dist/db.js

@@ -119,6 +119,7 @@ async function migrateSchema({ db, client, }) {
         'ALTER TABLE bot_tokens ADD COLUMN last_used_at DATETIME',
         "ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'",
         'ALTER TABLE thread_sessions ADD COLUMN last_synced_name TEXT',
+        'ALTER TABLE thread_sessions ADD COLUMN parent_session_id TEXT',
     ];
     for (const stmt of alterStatements) {
         await client.execute(stmt).catch(() => undefined);

package/dist/discord-bot.js

@@ -16,7 +16,7 @@ import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, resolveGuildMessageMember, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
-import { getTextAttachments, resolveMentions, } from './message-formatting.js';
+import { getFileAttachments, getTextAttachments, resolveMentions, } from './message-formatting.js';
 import { extractBtwSuffix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { forkSessionToBtwThread } from './commands/btw.js';
@@ -317,6 +317,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
                 ? promptMarker?.injectionGuardPatterns
                 : undefined;
+            const cliInjectedParentSessionId = isCliInjectedPrompt
+                ? promptMarker?.parentSessionId
+                : undefined;
             // Always ignore our own messages (unless CLI-injected prompt above).
             // Without this, assigning the Kimaki role to the bot itself would loop.
             if (isSelfBotMessage && !isCliInjectedPrompt) {
@@ -520,9 +523,14 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     ? extractBtwSuffix(message.content || '')
                     : null;
                 if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
+                    const btwSdkDir = worktreeInfo?.status === 'ready' &&
+                        worktreeInfo.workspace_directory
+                        ? worktreeInfo.workspace_directory
+                        : projectDirectory;
                     const result = await forkSessionToBtwThread({
                         sourceThread: thread,
                         projectDirectory,
+                        sdkDirectory: btwSdkDir,
                         prompt: btwResult.prompt,
                         userId: message.author.id,
                         username: message.member?.displayName || message.author.displayName,
@@ -606,6 +614,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                    parentSessionId: cliInjectedParentSessionId,
                     noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
@@ -627,7 +636,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
                 // Notify when a voice message was queued instead of sent immediately
                 if (enqueueResult.queued && enqueueResult.position) {
-                    await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit your message to update it in queue`);
+                    await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`);
                 }
             }
             if (channel.type === ChannelType.GuildText) {
@@ -816,6 +825,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 return;
             if (!message.content)
                 return;
+            // Discord fires MESSAGE_UPDATE for embed-only updates (link preview
+            // unfurling) without the user actually editing the message content.
+            // editedTimestamp is null for these; skip them to avoid false queue removals.
+            if (!message.editedTimestamp)
+                return;
             const channel = message.channel;
             const isThread = [
                 ChannelType.PublicThread,
@@ -850,6 +864,27 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Error handling message update:', error instanceof Error ? error.stack : String(error));
         }
     });
+    // Handle user message deletes to remove queued messages.
+    // Discord delete events do not include author/content, so attribution comes
+    // from the queued item captured at enqueue time.
+    discordClient.on(Events.MessageDelete, async (message) => {
+        try {
+            const channel = message.channel;
+            if (!channel.isThread())
+                return;
+            const runtime = getRuntime(channel.id);
+            if (!runtime)
+                return;
+            const removed = runtime.removeQueuedMessage(message.id);
+            if (!removed)
+                return;
+            discordLogger.log(`[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`);
+            await sendThreadMessage(channel, `⬦ **${removed.username}** removed message from queue`);
+        }
+        catch (error) {
+            discordLogger.error('Error handling message delete:', error instanceof Error ? error.stack : String(error));
+        }
+    });
     // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     // Uses JSON embed marker to pass options (start, worktree name)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
@@ -892,7 +927,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 return; // Not an auto-start thread
             }
             discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
-            const textAttachmentsContent = await getTextAttachments(starterMessage);
+            const [textAttachmentsContent, fileAttachments] = await Promise.all([
+                getTextAttachments(starterMessage),
+                getFileAttachments(starterMessage),
+            ]);
             const messageText = resolveMentions(starterMessage).trim();
             const prompt = textAttachmentsContent
                 ? `${messageText}\n\n${textAttachmentsContent}`
@@ -916,22 +954,31 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
                 return;
             }
-            // Start worktree creation concurrently if requested.
+            // Start worktree creation concurrently if requested via marker OR
+            // if the channel/global toggle enables auto-worktrees.
             // The runtime is created immediately so follow-up messages queue
             // naturally; the worktree promise is awaited inside enqueueIncoming.
+            const autoWorktreeEnabled = !marker.worktree &&
+                !marker.cwd &&
+                (store.getState().useWorktrees ||
+                    (await getChannelWorktreesEnabled(parent.id)));
+            const effectiveWorktreeName = marker.worktree ||
+                (autoWorktreeEnabled
+                    ? formatAutoWorktreeName(thread.name.slice(0, 50))
+                    : undefined);
             let worktreePromise;
-            if (marker.worktree && (await isGitRepositoryRoot(projectDirectory))) {
-                discordLogger.log(`[BOT_SESSION] Creating worktree: ${marker.worktree}`);
+            if (effectiveWorktreeName && (await isGitRepositoryRoot(projectDirectory))) {
+                discordLogger.log(`[BOT_SESSION] Creating worktree: ${effectiveWorktreeName}`);
                 const worktreeStatusMessage = await thread
                     .send({
-                    content: worktreeCreatingMessage(marker.worktree),
+                    content: worktreeCreatingMessage(effectiveWorktreeName),
                     flags: SILENT_MESSAGE_FLAGS,
                 })
                     .catch(() => undefined);
                 worktreePromise = createWorktreeInBackground({
                     thread,
                     starterMessage: worktreeStatusMessage,
-                    worktreeName: marker.worktree,
+                    worktreeName: effectiveWorktreeName,
                     projectDirectory,
                     rest: discordClient.rest,
                 });
@@ -939,6 +986,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             else if (marker.worktree) {
                 discordLogger.warn(`[BOT_SESSION] Skipping requested worktree for non-git project directory: ${projectDirectory}`);
             }
+            else if (autoWorktreeEnabled) {
+                discordLogger.warn(`[BOT_SESSION] Skipping auto-worktree for non-git project directory: ${projectDirectory}`);
+            }
             // --cwd: reuse an existing project subfolder or worktree directory. Revalidate at bot-time
             // (CLI validated at send-time but the path could become stale).
             // Only worktree directories are stored in thread_workspaces. Project
@@ -1017,6 +1067,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 model: marker.model,
                 permissions: marker.permissions,
                 injectionGuardPatterns: marker.injectionGuardPatterns,
+                parentSessionId: marker.parentSessionId,
                 mode: 'opencode',
                 sessionStartSource: botThreadStartSource
                     ? {
@@ -1028,7 +1079,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     const permissionRules = await getChannelReferencePermissionRules({
                         message: starterMessage,
                     });
-                    return { prompt, permissionRules, mode: 'opencode' };
+                    return {
+                        prompt,
+                        permissionRules,
+                        mode: 'opencode',
+                        ...(fileAttachments.length > 0 && { images: fileAttachments }),
+                    };
                 },
             });
         }

package/dist/interaction-handler.js

@@ -103,22 +103,13 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             // Multi-machine routing: only handle interactions for channels owned
             // by this machine (have a project directory configured in local db).
             // If not owned, silently return so the other machine handles it.
+            // Setup commands (create-new-project, add-project) bypass this check
+            // because they are designed to run from any channel — they create new
+            // project channels rather than requiring one to already exist.
+            const isSetupCommand = interaction.isChatInputCommand() &&
+                SETUP_COMMANDS.has(interaction.commandName);
             const owned = await isInteractionOwnedByThisMachine(interaction);
-            if (!owned) {
-                // Setup commands get a helpful reply instead of silent ignore.
-                // Both machines may race to reply; one wins, the other silently
-                // fails (interaction tokens are single-use). The message is the
-                // same from either machine so the race is harmless.
-                if (interaction.isChatInputCommand() &&
-                    SETUP_COMMANDS.has(interaction.commandName)) {
-                    await interaction.reply({
-                        content: 'Run this command in an existing Kimaki project channel.\nTo add a new project channel from the terminal, run:\n```\nkimaki project add /path/to/folder\n```',
-                        flags: MessageFlags.Ephemeral,
-                    }).catch(() => {
-                        // Another machine already responded, safe to ignore
-                    });
-                    return;
-                }
+            if (!owned && !isSetupCommand) {
                 interactionLogger.log(`[IGNORED] Channel ${interaction.channelId} has no project directory configured, skipping interaction`);
                 // Do not respond at all — consuming the interaction token would
                 // prevent the owning machine from responding (tokens are single-use).

package/dist/message-preprocessing.js

@@ -276,15 +276,22 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
         }
     }
     const qs = extractQueueSuffix(prompt);
+    const fileAttachments = await getFileAttachments(message);
+    const textAttachmentsContent = await getTextAttachments(message);
+    const finalPrompt = textAttachmentsContent
+        ? `${qs.prompt}\n\n${textAttachmentsContent}`
+        : qs.prompt;
     if (shouldSkipEmptyPrompt({
         message,
-        prompt: qs.prompt,
+        prompt: finalPrompt,
+        images: fileAttachments,
         hasVoiceAttachment,
     })) {
         return { prompt: '', mode: 'opencode', skip: true };
     }
     return {
-        prompt: qs.prompt,
+        prompt: finalPrompt,
+        images: fileAttachments.length > 0 ? fileAttachments : undefined,
         repliedMessage,
         permissionRules,
         mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',

package/dist/queue-advanced-e2e-setup.js

@@ -99,6 +99,27 @@ export function createDeterministicMatchers() {
             partDelaysMs: [0, 0, 0, 3_000, 0],
         },
     };
+    const slowBusyMatcher = {
+        id: 'slow-busy-reply',
+        priority: 100,
+        when: {
+            latestUserTextIncludes: 'SLOW_BUSY_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'slow-busy' },
+                { type: 'text-delta', id: 'slow-busy', delta: 'slow-busy-reply' },
+                { type: 'text-end', id: 'slow-busy' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 0, 0, 2_000, 0],
+        },
+    };
     const toolFollowupMatcher = {
         id: 'tool-followup',
         priority: 50,
@@ -704,6 +725,7 @@ export function createDeterministicMatchers() {
     };
     return [
         slowAbortMatcher,
+        slowBusyMatcher,
         typingRepulseMatcher,
         pluginTimeoutSleepMatcher,
         actionButtonClickFollowupMatcher,