kimaki 0.30.0 → 0.31.0

package/dist/commands/queue.js

@@ -5,7 +5,8 @@ import { deleteThreadQueueItem, getThreadSession } from '../database.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getOrCreateRuntime, getRuntime, } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { asSystemLine, QUEUE_PREFIX } from '../message-formatting.js';
+import { asSubtext, QUEUE_PREFIX } from '../message-formatting.js';
+import { extractBtwQueueSuffix } from '../btw-prefix-detection.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
 export const QUEUE_REMOVE_CUSTOM_ID_PREFIX = 'queue_remove:';
@@ -52,6 +53,19 @@ function buildQueueRemoveRow({ threadId, queueId, }) {
         .setLabel('Remove from queue')
         .setStyle(ButtonStyle.Secondary));
 }
+// Replies "Queued message" and returns the ack id, so the drain indicator can
+// reply to it. The runtime calls this inside the serialized enqueue.
+function replyQueuedAck({ command, threadId, }) {
+    return async ({ queueId, position }) => {
+        await command.reply({
+            content: asSubtext(`Queued message (position ${position})`),
+            components: [buildQueueRemoveRow({ threadId, queueId })],
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const ack = await command.fetchReply();
+        return ack.id;
+    };
+}
 export async function handleQueueRemoveButton(interaction) {
     const parsed = parseQueueRemoveCustomId(interaction.customId);
     if (!parsed) {
@@ -75,7 +89,7 @@ export async function handleQueueRemoveButton(interaction) {
         : await deleteThreadQueueItemWithoutRuntime(parsed.queueId);
     if (!removed) {
         await interaction.editReply({
-            content: asSystemLine('Queued message is no longer in the queue'),
+            content: asSubtext('Queued message is no longer in the queue'),
             components: [],
         });
         return;
@@ -84,14 +98,24 @@ export async function handleQueueRemoveButton(interaction) {
         ? `/${removed.command.name}`
         : removed.prompt.slice(0, 120);
     await interaction.editReply({
-        content: asSystemLine(`Removed queued message: ${label}`),
+        content: asSubtext(`Removed queued message: ${label}`),
         components: [],
     });
     logger.log(`[QUEUE] User ${interaction.user.displayName} removed queued item ${parsed.queueId} in thread ${parsed.threadId}`);
 }
 export async function handleQueueCommand({ command, appId, }) {
-    const message = command.options.getString('message', true);
+    // /queue always queues; a typed suffix is redundant, so only strip it.
+    const rawMessage = command.options.getString('message', true);
+    const btw = extractBtwQueueSuffix(rawMessage);
+    const message = btw.prompt;
     const channel = command.channel;
+    if (!message.trim()) {
+        await command.reply({
+            content: 'Write a message to queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     if (!channel) {
         await command.reply({
             content: 'This command can only be used in a channel',
@@ -139,23 +163,15 @@ export async function handleQueueCommand({ command, appId, }) {
     // /queue explicitly uses kimaki local queue mode.
     const enqueueResult = await runtime.enqueueIncoming({
         prompt: message,
+        queuedAction: btw.forceBtw ? 'btw' : undefined,
         userId: command.user.id,
         username: command.user.displayName,
         appId,
         mode: 'local-queue',
+        onLocalQueued: replyQueuedAck({ command, threadId: thread.id }),
     });
-    if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
-        await command.reply({
-            content: responseText,
-            components: [
-                buildQueueRemoveRow({
-                    threadId: thread.id,
-                    queueId: enqueueResult.queueId,
-                }),
-            ],
-            flags: SILENT_MESSAGE_FLAGS,
-        });
+    // onLocalQueued already posted the ack.
+    if (enqueueResult.queued) {
         return;
     }
     const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
@@ -205,7 +221,7 @@ export async function handleClearQueueCommand({ command, }) {
             return;
         }
         await command.reply({
-            content: asSystemLine(`Cleared queued message at position ${position}`),
+            content: asSubtext(`Cleared queued message at position ${position}`),
             flags: SILENT_MESSAGE_FLAGS,
         });
         logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
@@ -223,7 +239,7 @@ export async function handleClearQueueCommand({ command, }) {
         list = list.slice(0, 597) + '...';
     }
     await command.reply({
-        content: asSystemLine(`Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`),
+        content: asSubtext(`Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`),
         flags: SILENT_MESSAGE_FLAGS,
     });
     logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
@@ -297,19 +313,10 @@ export async function handleQueueCommandCommand({ command, appId, }) {
         appId,
         command: commandPayload,
         mode: 'local-queue',
+        onLocalQueued: replyQueuedAck({ command, threadId: thread.id }),
     });
-    if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
-        await command.reply({
-            content: responseText,
-            components: [
-                buildQueueRemoveRow({
-                    threadId: thread.id,
-                    queueId: enqueueResult.queueId,
-                }),
-            ],
-            flags: SILENT_MESSAGE_FLAGS,
-        });
+    // onLocalQueued already posted the ack.
+    if (enqueueResult.queued) {
         logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
         return;
     }

package/dist/commands/session.js

@@ -12,6 +12,7 @@ import { sendThreadMessage, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, resol
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { DiscordOperationError } from '../errors.js';
+import { extractQueueSuffix } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.SESSION);
 // Create only: callers confirm the destination before dispatching the full prompt.
 export async function createNewSessionThread({ textChannel, projectDirectory, sourceWorkspace, prompt, files = [], userId, }) {
@@ -54,10 +55,14 @@ export async function createNewSessionThread({ textChannel, projectDirectory, so
 }
 export async function handleSessionCommand({ command, appId, }) {
     await command.deferReply();
-    const prompt = command.options.getString('prompt', true);
+    const { prompt, forceQueue } = extractQueueSuffix(command.options.getString('prompt', true));
     const filesString = command.options.getString('files') || '';
     const agent = command.options.getString('agent') || undefined;
     const channel = command.channel;
+    if (!prompt.trim()) {
+        await command.editReply('Write a prompt for the new session');
+        return;
+    }
     const isThread = channel && [
         ChannelType.PublicThread,
         ChannelType.PrivateThread,
@@ -139,7 +144,7 @@ export async function handleSessionCommand({ command, appId, }) {
         username: command.user.displayName,
         agent,
         appId,
-        mode: 'opencode',
+        mode: forceQueue ? 'local-queue' : 'opencode',
     }).catch(async (error) => {
         logger.error('New session dispatch failed:', error);
         await sendThreadMessage(thread, 'Could not send the request to OpenCode. Send your request again in this thread.');

package/dist/db.test.js

@@ -7,11 +7,11 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionAgent, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionAgent, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
 import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
-import { copyCurrentSessionModel } from './commands/model.js';
+import { copySessionPreferences } from './commands/model.js';
 afterAll(async () => {
     await closeDb();
 });
@@ -566,7 +566,9 @@ describe('getDb', () => {
         await db.delete(schema.thread_workspaces).where(orm.eq(schema.thread_workspaces.thread_id, threadId));
         await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
     });
-    test('copyCurrentSessionModel snapshots source session model to forked session', async () => {
+    // Regression: btw forks lost the agent and ran `build` instead of the source
+    // agent, which changed tools and busted the whole prompt cache.
+    test('copySessionPreferences snapshots source session agent and model to forked session', async () => {
         const db = await getDb();
         const sourceSessionId = `test-source-session-${crypto.randomUUID()}`;
         const targetSessionId = `test-target-session-${crypto.randomUUID()}`;
@@ -578,18 +580,26 @@ describe('getDb', () => {
             modelId: 'anthropic/claude-opus-4-6',
             variant: 'thinking',
         });
-        await copyCurrentSessionModel({
+        await setSessionAgent(sourceSessionId, 'opus');
+        await copySessionPreferences({
             sourceSessionId,
             targetSessionId,
             getClient,
         });
-        await expect(getSessionModel(targetSessionId)).resolves.toMatchInlineSnapshot(`
+        expect({
+            agent: await getSessionAgent(targetSessionId),
+            model: await getSessionModel(targetSessionId),
+        }).toMatchInlineSnapshot(`
       {
-        "modelId": "anthropic/claude-opus-4-6",
-        "variant": "thinking",
+        "agent": "opus",
+        "model": {
+          "modelId": "anthropic/claude-opus-4-6",
+          "variant": "thinking",
+        },
       }
     `);
         await db.delete(schema.session_models).where(orm.inArray(schema.session_models.session_id, [sourceSessionId, targetSessionId]));
+        await db.delete(schema.session_agents).where(orm.inArray(schema.session_agents.session_id, [sourceSessionId, targetSessionId]));
     });
     test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
         const db = await getDb();

package/dist/discord-bot.js

@@ -13,15 +13,15 @@ import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
-import { asSystemLine, STATUS_PREFIX } from './message-formatting.js';
+import { asSubtext } from './message-formatting.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 { getFileAttachments, getTextAttachments, resolveMentions, } from './message-formatting.js';
-import { extractBtwSuffix } from './btw-prefix-detection.js';
+import { getFileAttachments, getTextAttachments, resolveContentMentions } from './message-formatting.js';
+import { extractBtwQueueSuffix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { forkSessionToBtwThread } from './commands/btw.js';
-import { extractQueueSuffix, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
+import { preprocessExistingThreadMessage, preprocessNewThreadMessage, resolveMessagePrompt, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
@@ -48,7 +48,7 @@ export { initializeOpencodeForDirectory, assertCompatibleOpencodeVersion } from
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, } from './discord-utils.js';
 export { getOpencodeSystemMessage } from './system-message.js';
 export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, createDefaultKimakiChannel, getChannelsWithDescriptions, } from './channel-management.js';
-import { ChannelType, Client, Events, GatewayIntentBits, Partials, ThreadAutoArchiveDuration, } from 'discord.js';
+import { ChannelType, Client, Events, RESTEvents, GatewayIntentBits, Partials, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import dedent from 'string-dedent';
@@ -299,6 +299,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     discordClient.on(Events.Error, (error) => {
         discordLogger.error('[GATEWAY] Client error:', formatErrorWithStack(error));
     });
+    // discord.js silently waits out 429s, so log them to explain slow REST calls.
+    discordClient.rest.on(RESTEvents.RateLimited, (info) => {
+        discordLogger.warn(`[REST] Rate limited ${info.method} ${info.route} retryAfter=${info.retryAfter}ms scope=${info.scope} global=${info.global} sublimitTimeout=${info.sublimitTimeout}ms`);
+    });
     discordClient.on(Events.ShardError, (error, shardId) => {
         const state = getOrCreateShardState(shardId);
         state.lastError = error;
@@ -596,35 +600,54 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     // `. btw` suffix mirrors /btw for fast side-question forks.
                     // Works like queue: just the word "btw" at the end after punctuation
                     // or newline. The whole message (minus the suffix) becomes the fork prompt.
-                    const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
-                        ? extractBtwSuffix(message.content || '')
-                        : null;
-                    if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
+                    const suffix = extractBtwQueueSuffix(message.content || '');
+                    if (suffix.forceBtw && !suffix.forceQueue && projectDirectory
+                        && worktreeInfo?.status !== 'pending' && !isLeadingMentionToOtherUser) {
                         threadIngressSlot?.release();
                         const btwSdkDir = worktreeInfo?.status === 'ready' &&
                             worktreeInfo.workspace_directory
                             ? worktreeInfo.workspace_directory
                             : projectDirectory;
+                        // Ack right away: fork + thread creation can take seconds. Runs in
+                        // parallel with the fork and is edited with the result at the end.
+                        const ackPromise = message.reply({
+                            content: asSubtext('Forking session to answer this side question...'),
+                            flags: SILENT_MESSAGE_FLAGS,
+                        }).catch((error) => {
+                            discordLogger.warn('Could not send btw ack:', error);
+                            return undefined;
+                        });
+                        // Long `kimaki send` prompts arrive as prompt.md, so the fork needs attachments too.
+                        const [btwImages, btwTextAttachments] = await Promise.all([
+                            getFileAttachments(message),
+                            getTextAttachments(message),
+                        ]);
                         const result = await forkSessionToBtwThread({
                             sourceThread: thread,
                             projectDirectory,
                             sdkDirectory: btwSdkDir,
-                            prompt: btwResult.prompt,
-                            userId: message.author.id,
-                            username: message.member?.displayName || message.author.displayName,
+                            prompt: suffix.prompt,
+                            modelPrompt: [suffix.prompt, btwTextAttachments].filter(Boolean).join('\n\n'),
+                            images: btwImages.length > 0 ? btwImages : undefined,
+                            userId: cliInjectedUserId || message.author.id,
+                            username: cliInjectedUsername ||
+                                message.member?.displayName ||
+                                message.author.displayName,
                             appId: currentAppId,
                         });
-                        if (result instanceof Error) {
-                            await message.reply({
-                                content: result.message,
-                                flags: SILENT_MESSAGE_FLAGS,
-                            });
-                            return;
+                        const resultContent = result instanceof Error
+                            ? result.message
+                            : `Session forked! Continue in ${result.thread.toString()}`;
+                        const ack = await ackPromise;
+                        const edited = ack
+                            ? await ack.edit({ content: resultContent }).catch((error) => {
+                                discordLogger.warn('Could not edit btw ack:', error);
+                                return undefined;
+                            })
+                            : undefined;
+                        if (!edited) {
+                            await message.reply({ content: resultContent, flags: SILENT_MESSAGE_FLAGS });
                         }
-                        await message.reply({
-                            content: `Session forked! Continue in ${result.thread.toString()}`,
-                            flags: SILENT_MESSAGE_FLAGS,
-                        });
                         return;
                     }
                     const hasVoiceAttachment = message.attachments.some((attachment) => {
@@ -677,7 +700,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         }
                         void cancelPendingFileUpload(thread.id);
                     };
-                    if (!hasVoiceAttachment) {
+                    if (!hasVoiceAttachment && !suffix.forceQueue) {
                         await dismissSourceUi();
                     }
                     // A sleep wake only becomes a turn if it can still claim its own row.
@@ -707,6 +730,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                             message.author.displayName,
                         sourceMessageId: message.id,
                         sourceThreadId: thread.id,
+                        sourceChannelId: message.channelId,
                         appId: currentAppId,
                         agent: cliInjectedAgent,
                         model: cliInjectedModel,
@@ -734,7 +758,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                             });
                             // Routing must finish before touching source UI. This chain is separate
                             // from dispatchAction, so abort waiting does not block session events.
-                            if (hasVoiceAttachment && !result.skip) {
+                            if (hasVoiceAttachment && !result.skip && result.mode !== 'local-queue') {
                                 await dismissSourceUi();
                             }
                             return result;
@@ -742,7 +766,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, asSystemLine(`Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`));
+                        await sendThreadMessage(thread, asSubtext(`Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`));
                     }
                 }
                 if (channel.type === ChannelType.GuildText) {
@@ -879,6 +903,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         username: message.member?.displayName || message.author.displayName,
                         sourceMessageId: message.id,
                         sourceThreadId: thread.id,
+                        sourceChannelId: message.channelId,
                         appId: currentAppId,
                         preprocess: async () => {
                             return preprocessNewThreadMessage({
@@ -944,22 +969,27 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const runtime = getRuntime(channel.id);
             if (!runtime)
                 return;
-            // Use resolveMentions to match initial preprocessing and preserve
-            // newlines (stripMentions collapses them, breaking final-line queue
-            // suffix detection).
-            const { prompt, forceQueue } = extractQueueSuffix(resolveMentions(message));
+            // Same resolution as initial ingress, so the edited prompt matches.
+            const { prompt, mode, queuedAction } = await resolveMessagePrompt({
+                message,
+                text: resolveContentMentions(message),
+            });
             // If the edit removed the queue suffix, remove the item from the queue.
             // If the suffix is still present, update the prompt.
-            const result = await runtime.updateQueuedMessage(message.id, forceQueue ? prompt : '');
+            const result = await runtime.updateQueuedMessage({
+                sourceMessageId: message.id,
+                newPrompt: mode === 'local-queue' ? prompt : '',
+                queuedAction,
+            });
             if (result.found && channel.isThread()) {
                 const displayName = message.member?.displayName ?? message.author.displayName;
                 if (result.removed) {
                     discordLogger.log(`[MESSAGE_EDIT] Removed queued message ${message.id} in thread ${channel.id}`);
-                    await sendThreadMessage(channel, `${STATUS_PREFIX}**${displayName}** removed message from queue`);
+                    await sendThreadMessage(channel, asSubtext(`**${displayName}** removed message from queue`));
                 }
                 else {
                     discordLogger.log(`[MESSAGE_EDIT] Updated queued message ${message.id} in thread ${channel.id}`);
-                    await sendThreadMessage(channel, `${STATUS_PREFIX}**${displayName}** edited queued message`);
+                    await sendThreadMessage(channel, asSubtext(`**${displayName}** edited queued message`));
                 }
             }
         }
@@ -982,7 +1012,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (!removed)
                 return;
             discordLogger.log(`[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`);
-            await sendThreadMessage(channel, `${STATUS_PREFIX}**${removed.username}** removed message from queue`);
+            await sendThreadMessage(channel, asSubtext(`**${removed.username}** removed message from queue`));
         }
         catch (error) {
             discordLogger.error('Error handling message delete:', error instanceof Error ? error.stack : String(error));
@@ -1030,14 +1060,11 @@ 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, fileAttachments] = await Promise.all([
-                getTextAttachments(starterMessage),
-                getFileAttachments(starterMessage),
-            ]);
-            const messageText = resolveMentions(starterMessage).trim();
-            const prompt = textAttachmentsContent
-                ? `${messageText}\n\n${textAttachmentsContent}`
-                : messageText;
+            const resolvedPrompt = await resolveMessagePrompt({
+                message: starterMessage,
+                text: resolveContentMentions(starterMessage).trim(),
+            });
+            const { prompt } = resolvedPrompt;
             if (!prompt) {
                 discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);
                 return;
@@ -1163,7 +1190,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 permissions: marker.permissions,
                 injectionGuardPatterns: marker.injectionGuardPatterns,
                 parentSessionId: marker.parentSessionId,
-                mode: 'opencode',
+                mode: resolvedPrompt.mode,
                 sessionStartSource: botThreadStartSource
                     ? {
                         scheduleKind: botThreadStartSource.scheduleKind,
@@ -1172,11 +1199,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                     : undefined,
                 preprocess: async () => {
-                    return {
-                        prompt,
-                        mode: 'opencode',
-                        ...(fileAttachments.length > 0 && { images: fileAttachments }),
-                    };
+                    return resolvedPrompt;
                 },
             });
         }

package/dist/discord-utils.js

@@ -10,8 +10,9 @@ import { discordApiUrl } from './discord-urls.js';
 import { Lexer } from 'marked';
 import { splitTablesFromMarkdown } from './format-tables.js';
 import { sessionPartContent, shouldLeadWithBlankLine, } from './message-formatting.js';
-import { getChannelDirectory, getThreadWorktreeOrWorkspace } from './database.js';
+import { getChannelDirectory, getThreadIdBySessionId, getThreadWorktreeOrWorkspace } from './database.js';
 import { DiscordOperationError } from './errors.js';
+import YAML from 'yaml';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -20,6 +21,19 @@ import mime from 'mime';
 import fs from 'node:fs';
 import path from 'node:path';
 const discordLogger = createLogger(LogPrefix.DISCORD);
+/** Starter embed with the YAML marker. Links the parent thread when the parent session is known locally. */
+export async function buildThreadStartEmbeds(marker) {
+    const parentThreadId = marker.parentSessionId
+        ? await getThreadIdBySessionId(marker.parentSessionId)
+        : undefined;
+    return [
+        {
+            color: 0x2b2d31,
+            ...(parentThreadId && { description: `Parent thread: <#${parentThreadId}>` }),
+            footer: { text: YAML.stringify(marker) },
+        },
+    ];
+}
 /**
  * Centralized permission check for Kimaki bot access.
  * Returns true if the member has permission to use the bot:

package/dist/errors.js

@@ -63,6 +63,16 @@ export class TranscriptionError extends errore.createTaggedError({
     message: 'Transcription failed: $reason',
 }) {
 }
+export class TranscriptionApiError extends errore.createTaggedError({
+    name: 'TranscriptionApiError',
+    message: 'Transcription API returned HTTP $status: $body',
+}) {
+}
+export class TranscriptionBlockedError extends errore.createTaggedError({
+    name: 'TranscriptionBlockedError',
+    message: 'Transcription blocked by the provider content filter ($reason)',
+}) {
+}
 export class SpeechGenerationError extends errore.createTaggedError({
     name: 'SpeechGenerationError',
     message: 'Speech generation failed: $reason',
@@ -96,11 +106,6 @@ export class NoResponseContentError extends errore.createTaggedError({
     message: 'No response content from model',
 }) {
 }
-export class NoToolResponseError extends errore.createTaggedError({
-    name: 'NoToolResponseError',
-    message: 'No valid tool responses',
-}) {
-}
 // ═══════════════════════════════════════════════════════════════════════════
 // BOUNDARY ERRORS - Wrapping external library exceptions at .catch() sites
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/external-directory-permissions.e2e.test.js

@@ -67,18 +67,18 @@ describe('external directory permissions', () => {
       -# *using deterministic-provider/deterministic-v2*
       > reading external directory
 
-      ┣ read *probe.txt*
+      -# ┣ read *probe.txt*
 
-      > external-directory-probe-done
+      external-directory-probe-done
       -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
       > reading external directory
 
-      ┣ read *probe.txt*
+      -# ┣ read *probe.txt*
 
-      > external-directory-probe-done
+      external-directory-probe-done
       -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
     `);
         expect(text).not.toContain('Permission Required');

package/dist/external-directory-project-deny.e2e.test.js

@@ -57,9 +57,9 @@ describe('external directory project deny', () => {
       -# *using deterministic-provider/deterministic-v2*
       > reading external directory
 
-      ┣ read *probe.txt*
+      -# ┣ read *probe.txt*
 
-      > external-directory-probe-denied"
+      external-directory-probe-denied"
     `);
         // A deny is silent: it must not fall back to asking the user.
         expect(text).not.toContain('Permission Required');

package/dist/gateway-proxy.e2e.test.js

@@ -324,7 +324,7 @@ describeIf('gateway-proxy e2e', () => {
         hello from gateway proxy test
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        > gateway-proxy-reply
+        gateway-proxy-reply
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(reply).toBeDefined();
@@ -351,12 +351,12 @@ describeIf('gateway-proxy e2e', () => {
         hello from gateway proxy test
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        > gateway-proxy-reply
+        gateway-proxy-reply
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        > gateway-proxy-reply
+        gateway-proxy-reply
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(reply).toBeDefined();
@@ -383,12 +383,12 @@ describeIf('gateway-proxy e2e', () => {
         hello from gateway proxy test
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        > gateway-proxy-reply
+        gateway-proxy-reply
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        > gateway-proxy-reply
+        gateway-proxy-reply
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         !echo proxy-shell-test