kimaki 0.27.0 → 0.28.0

package/dist/cli-send-thread.e2e.test.js

@@ -319,9 +319,9 @@ describe('kimaki send --channel thread creation', () => {
         "--- from: user (cli-send-tester)
         thread empty content seed
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ caught-by-model
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000830>
+        > *using deterministic-provider/deterministic-v2*
+        > caught-by-model
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000830>
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)
         I can see you sent a message, but Discord did not include its text.
@@ -436,13 +436,13 @@ describe('kimaki send --channel thread creation', () => {
         }));
         // Add test user to thread
         await botClient.rest.put(Routes.threadMembers(threadData.id, TEST_USER_ID));
-        // Wait for the bot to reply with the ⬥ prefix (proves ThreadCreate
-        // handler picked up the starter message and started a session)
+        // Wait for the bot to reply (proves ThreadCreate handler picked up
+        // the starter message and started a session)
         await waitForBotMessageContaining({
             discord,
             threadId: threadData.id,
             userId: discord.botUserId,
-            text: '⬥',
+            text: 'ok',
             timeout: 4_000,
         });
         // Wait for footer message (proves session completed successfully)
@@ -450,7 +450,7 @@ describe('kimaki send --channel thread creation', () => {
             discord,
             threadId: threadData.id,
             timeout: 4_000,
-            afterMessageIncludes: '⬥',
+            afterMessageIncludes: 'ok',
             afterAuthorId: discord.botUserId,
         });
         // Verify no DiscordAPIError[160004] or other errors in the thread.
@@ -461,9 +461,9 @@ describe('kimaki send --channel thread creation', () => {
             return m.content.includes('Error:') || m.content.includes('160004');
         });
         expect(errorMessages).toHaveLength(0);
-        // Verify at least one ⬥ reply exists (session produced output)
+        // Verify at least one reply exists (session produced output)
         const botReplies = messages.filter((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('⬥'));
+            return m.author.id === discord.botUserId;
         });
         expect(botReplies.length).toBeGreaterThanOrEqual(1);
     }, 15_000);

package/dist/commands/action-buttons.js

@@ -6,6 +6,7 @@ import crypto from 'node:crypto';
 import { getThreadSession } from '../database.js';
 import { NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { notifyError } from '../sentry.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 const logger = createLogger('ACT_BTN');
@@ -214,7 +215,7 @@ export async function handleActionButton(interaction) {
     });
     const username = interaction.user.globalName || interaction.user.username;
     const prompt = `User clicked: ${button.label}`;
-    await sendThreadMessage(thread, `» **${username}:** ${button.label}`);
+    await sendThreadMessage(thread, `${QUEUE_PREFIX}**${username}:** ${button.label}`);
     try {
         await sendClickedActionToModel({
             interaction,

package/dist/commands/add-project.js

@@ -1,7 +1,7 @@
 // /add-project command - Create Discord channels for an existing OpenCode project.
 import fs from 'node:fs';
 import path from 'node:path';
-import { findChannelsByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { findRegisteredTextChannelForDirectory, getAllTextChannelDirectories, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -38,12 +38,9 @@ export async function handleAddProjectCommand({ command, }) {
             await command.editReply(`Directory does not exist: ${directory}`);
             return;
         }
-        const existingChannels = await findChannelsByDirectory({
-            directory,
-            channelType: 'text',
-        });
-        if (existingChannels.length > 0) {
-            await command.editReply(`A channel already exists for this directory: <#${existingChannels[0].channel_id}>`);
+        const existingChannel = await findRegisteredTextChannelForDirectory(directory);
+        if (existingChannel) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
             return;
         }
         const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({

package/dist/commands/agent.js

@@ -2,18 +2,22 @@
 // Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
 // When a prompt is provided to a quick agent command (e.g. /plan-agent "fix the bug"),
 // the prompt is sent with that agent and the session keeps that agent afterwards.
+// Optional last `variant` option sets the model thinking level for that agent.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, getChannelWorktreesEnabled, } from '../database.js';
+import { setChannelAgent, setSessionAgent, setSessionModel, setChannelModel, getChannelModel, 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 { resolveTextChannel, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getOrCreateRuntime, releaseCurrentThreadIngress, waitForCurrentThreadIngress, } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { formatModelSource, 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 { QUEUE_PREFIX } from '../message-formatting.js';
 import { store } from '../store.js';
+import { getThinkingValuesForModel, resolveRequestedThinkingVariant, } from '../thinking-utils.js';
+import { OpenCodeSdkError } from '../errors.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
 const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000;
 const pendingAgentContexts = new Map();
@@ -161,6 +165,48 @@ export async function setAgentForContext({ context, agentName, }) {
         agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`);
     }
 }
+async function applyQuickAgentVariant({ context, agentName, variant, }) {
+    const modelInfo = await resolveAgentModelInfo({ context, agentName });
+    if (modelInfo.type === 'none') {
+        agentLogger.warn(`[AGENT] Skipping variant ${variant}: no model for agent ${agentName}`);
+        return undefined;
+    }
+    const getClient = await initializeOpencodeForDirectory(context.dir);
+    if (getClient instanceof Error)
+        return undefined;
+    const providersResponse = await getClient()
+        .provider.list({ directory: context.workingDirectory })
+        .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }));
+    if (providersResponse instanceof Error || !providersResponse.data) {
+        agentLogger.warn(`[AGENT] Skipping variant ${variant}: provider list failed`);
+        return undefined;
+    }
+    const matchedVariant = resolveRequestedThinkingVariant({
+        requestedValue: variant,
+        providers: providersResponse.data.all,
+        providerId: modelInfo.providerID,
+        modelId: modelInfo.modelID,
+    });
+    if (!matchedVariant) {
+        agentLogger.warn(`[AGENT] Skipping variant ${variant}: not supported by ${modelInfo.model}`);
+        return undefined;
+    }
+    if (context.isThread && context.sessionId) {
+        await setSessionModel({
+            sessionId: context.sessionId,
+            modelId: modelInfo.model,
+            variant: matchedVariant,
+        });
+        return matchedVariant;
+    }
+    const existing = await getChannelModel(context.channelId);
+    await setChannelModel({
+        channelId: context.channelId,
+        modelId: existing?.modelId ?? modelInfo.model,
+        variant: matchedVariant,
+    });
+    return matchedVariant;
+}
 function formatAgentModelLine(modelInfo) {
     if (modelInfo.type === 'none')
         return '';
@@ -174,15 +220,16 @@ function formatAgentModelLine(modelInfo) {
     }
     return `${line}\nThis model comes from a ${modelInfo.type} override. Use /model and press Clear override if you want this agent's model.`;
 }
-function formatAgentPreferenceReply({ agentName, previousAgentName, modelInfo, scope, }) {
+function formatAgentPreferenceReply({ agentName, previousAgentName, modelInfo, scope, variant, }) {
     const sameAgent = previousAgentName === agentName;
     const verb = sameAgent ? 'Using' : 'Switched to';
     const previousText = !sameAgent && previousAgentName ? ` (was **${previousAgentName}**)` : '';
     const modelText = formatAgentModelLine(modelInfo);
+    const variantText = variant ? `\nVariant: **${variant}**` : '';
     if (scope === 'session') {
-        return `${verb} **${agentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`;
+        return `${verb} **${agentName}** agent for this session${previousText}${modelText}${variantText}\nThe agent will change on the next message.`;
     }
-    return `${verb} **${agentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`;
+    return `${verb} **${agentName}** agent for this channel${previousText}${modelText}${variantText}\nAll new sessions will use this agent.`;
 }
 async function resolveAgentModelInfo({ context, agentName, }) {
     const getClient = await initializeOpencodeForDirectory(context.dir);
@@ -296,7 +343,13 @@ export async function handleAgentSelectMenu(interaction) {
             channelId: context.channelId,
         });
         const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
-        await setAgentForContext({ context, agentName: selectedAgent });
+        await waitForCurrentThreadIngress();
+        try {
+            await setAgentForContext({ context, agentName: selectedAgent });
+        }
+        finally {
+            releaseCurrentThreadIngress();
+        }
         const modelInfo = await resolveAgentModelInfo({
             context,
             agentName: selectedAgent,
@@ -333,9 +386,16 @@ export async function handleAgentSelectMenu(interaction) {
 export async function handleQuickAgentCommand({ command, appId, }) {
     const fallbackAgentName = command.commandName.replace(/-agent$/, '');
     const prompt = command.options.getString('prompt') || undefined;
+    const variant = command.options.getString('variant') || undefined;
     // Prompt mode: send the prompt with this agent immediately.
     if (prompt) {
-        return handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt });
+        return handleQuickAgentWithPrompt({
+            command,
+            appId,
+            fallbackAgentName,
+            prompt,
+            variant,
+        });
     }
     // No prompt: switch the persistent agent preference (original behavior).
     await command.deferReply();
@@ -356,20 +416,37 @@ export async function handleQuickAgentCommand({ command, appId, }) {
             channelId: context.channelId,
         });
         const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
-        await setAgentForContext({ context, agentName: resolvedAgentName });
-        const modelInfo = await resolveAgentModelInfo({
-            context,
-            agentName: resolvedAgentName,
-        });
-        const scope = context.isThread && context.sessionId ? 'session' : 'channel';
-        await command.editReply({
-            content: formatAgentPreferenceReply({
+        await waitForCurrentThreadIngress();
+        try {
+            await setAgentForContext({ context, agentName: resolvedAgentName });
+            const modelInfo = await resolveAgentModelInfo({
+                context,
                 agentName: resolvedAgentName,
-                previousAgentName,
-                modelInfo,
-                scope,
-            }),
-        });
+            });
+            const appliedVariant = variant
+                ? await applyQuickAgentVariant({
+                    context,
+                    agentName: resolvedAgentName,
+                    variant,
+                })
+                : undefined;
+            const scope = context.isThread && context.sessionId ? 'session' : 'channel';
+            const unsupportedVariantNote = variant && !appliedVariant
+                ? `\nVariant **${variant}** is not supported by this agent's model.`
+                : '';
+            await command.editReply({
+                content: `${formatAgentPreferenceReply({
+                    agentName: resolvedAgentName,
+                    previousAgentName,
+                    modelInfo,
+                    scope,
+                    variant: appliedVariant,
+                })}${unsupportedVariantNote}`,
+            });
+        }
+        finally {
+            releaseCurrentThreadIngress();
+        }
     }
     catch (error) {
         agentLogger.error('Error in quick agent command:', error);
@@ -384,7 +461,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
  * In a channel: create a new thread whose session starts with the requested agent.
  * Channel-level preferences are not changed.
  */
-async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt, }) {
+async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt, variant, }) {
     const channel = command.channel;
     if (!channel) {
         await command.reply({
@@ -422,7 +499,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
         });
         // Visible reply showing the one-shot prompt (not ephemeral, so it appears in thread).
         await command.reply({
-            content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+            content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         await runtime.enqueueIncoming({
@@ -432,6 +509,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             agent: resolvedAgentName,
             appId,
             mode: 'opencode',
+            variant,
         });
     }
     else if (channel.type === ChannelType.GuildText) {
@@ -459,7 +537,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             ? `${WORKTREE_PREFIX}${baseThreadName}`
             : baseThreadName;
         const starterMessage = await channel.send({
-            content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+            content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
@@ -513,6 +591,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             agent: resolvedAgentName,
             appId,
             mode: 'opencode',
+            variant,
         });
     }
     else {
@@ -522,3 +601,58 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
         });
     }
 }
+export async function handleQuickAgentAutocomplete({ interaction, }) {
+    if (interaction.options.getFocused(true).name !== 'variant') {
+        await interaction.respond([]);
+        return;
+    }
+    const focusedValue = interaction.options.getFocused().trim().toLowerCase();
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await interaction.respond([]);
+        return;
+    }
+    const [providersResponse, agentsResponse] = await Promise.all([
+        getClient()
+            .provider.list({ directory: projectDirectory })
+            .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e })),
+        getClient()
+            .app.agents({ directory: projectDirectory })
+            .catch((e) => new OpenCodeSdkError({ operation: 'app.agents', cause: e })),
+    ]);
+    if (providersResponse instanceof Error || agentsResponse instanceof Error) {
+        agentLogger.warn('[AUTOCOMPLETE] Failed to fetch variant choices');
+        await interaction.respond([]);
+        return;
+    }
+    if (!providersResponse.data || !agentsResponse.data) {
+        await interaction.respond([]);
+        return;
+    }
+    const resolvedAgentName = parseQuickAgentNameFromDescription(interaction.command?.description) ||
+        interaction.commandName.replace(/-agent$/, '');
+    const agent = agentsResponse.data.find((candidate) => candidate.name === resolvedAgentName);
+    const agentModel = agent?.model;
+    if (!agentModel) {
+        await interaction.respond([]);
+        return;
+    }
+    const variants = getThinkingValuesForModel({
+        providers: providersResponse.data.all,
+        providerId: agentModel.providerID,
+        modelId: agentModel.modelID,
+    }).filter((variant) => {
+        if (!focusedValue)
+            return true;
+        return variant.toLowerCase().includes(focusedValue);
+    });
+    await interaction.respond(variants.slice(0, 25).map((variant) => ({
+        name: variant.slice(0, 100),
+        value: variant,
+    })));
+}

package/dist/commands/ask-question.js

@@ -7,6 +7,7 @@ import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '.
 import { getOpencodeClient } from '../opencode.js';
 import { DiscordOperationError } from '../errors.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.ASK_QUESTION);
 // Store pending question contexts by hash.
 // No TTL on purpose: a question can only be answered by the user, so expiring it
@@ -183,7 +184,7 @@ export async function handleAskQuestionSelectMenu(interaction) {
         components: [], // Remove the dropdown
     });
     const username = interaction.user.globalName || interaction.user.username;
-    await sendThreadMessage(context.thread, `» **${username}:** ${answeredText}`);
+    await sendThreadMessage(context.thread, `${QUEUE_PREFIX}**${username}:** ${answeredText}`);
     // Check if all questions are answered
     if (areAllQuestionsAnswered(context)) {
         // All questions answered - send result back to session

package/dist/commands/btw.js

@@ -3,14 +3,14 @@
 // a new thread, forks the entire session (no messageID), and immediately
 // dispatches the user's prompt so the forked session starts working right away.
 import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
-import { getThreadSession, setThreadSession } from '../database.js';
+import { getThreadSession, setThreadSession, getThreadWorktreeOrWorkspace, createPendingWorkspace, setWorkspaceReady, } from '../database.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.FORK);
-export async function forkSessionToBtwThread({ sourceThread, projectDirectory, sdkDirectory, prompt, userId, username, appId, }) {
+export async function forkSessionToBtwThread({ sourceThread, projectDirectory, sdkDirectory, prompt, modelPrompt = prompt, userId, username, appId, agent, images, }) {
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
     const [sessionId, getClientResult, textChannel] = await Promise.all([
         getThreadSession(sourceThread.id),
@@ -29,7 +29,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         return new Error('Could not resolve parent text channel');
     }
     // Fork must succeed before creating the Discord thread to avoid orphan threads
-    const forkResponse = await getClientResult().session.fork({ sessionID: sessionId });
+    const forkResponse = await getClientResult().session.fork({ sessionID: sessionId, directory: sdkDirectory });
     if (!forkResponse.data) {
         return new Error('Failed to fork session');
     }
@@ -41,7 +41,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         channelId,
         appId,
         getClient: getClientResult,
-        directory: projectDirectory,
+        directory: sdkDirectory,
     });
     const thread = await textChannel.threads.create({
         name: `btw: ${prompt}`.slice(0, 100),
@@ -50,10 +50,26 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
     });
     // DB mapping must complete before user-visible actions so the thread is routable
     await setThreadSession(thread.id, forkedSession.id);
+    const sourceWorkspace = await getThreadWorktreeOrWorkspace(sourceThread.id);
+    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,
+        });
+    }
     // Parallelize: member add and status message are independent best-effort actions
     const sourceThreadLink = `<#${sourceThread.id}>`;
     await Promise.all([
-        thread.members.add(userId).catch(() => { }),
+        thread.members.add(userId).catch((error) => {
+            logger.warn('Could not add fork member:', error);
+        }),
         sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`),
     ]);
     logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId})`);
@@ -68,7 +84,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
         `Do NOT send messages to the parent session unless the user explicitly asks you to.`,
         ``,
-        prompt,
+        modelPrompt,
     ].join('\n');
     const runtime = getOrCreateRuntime({
         threadId: thread.id,
@@ -77,13 +93,19 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         sdkDirectory,
         channelId,
         appId,
+        sessionId: forkedSession.id,
     });
     await runtime.enqueueIncoming({
         prompt: wrappedPrompt,
+        agent,
+        images,
         userId,
         username,
         appId,
         mode: 'opencode',
+    }).catch(async (error) => {
+        logger.error('Fork dispatch failed:', error);
+        await sendThreadMessage(thread, 'Could not send the request to OpenCode. Send your request again in this thread.');
     });
     return {
         thread,

package/dist/commands/file-upload.js

@@ -12,6 +12,7 @@ import path from 'node:path';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { NOTIFY_MESSAGE_FLAGS, sendThreadMessage } from '../discord-utils.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.FILE_UPLOAD);
 // 5 minute TTL for pending contexts - if user doesn't click within this time,
 // clean up the context and resolve with empty array to unblock the plugin tool
@@ -221,7 +222,7 @@ export async function handleFileUploadModalSubmit(interaction) {
         await interaction.editReply({ content: summary });
         if (downloadedPaths.length > 0) {
             const username = interaction.user.globalName || interaction.user.username;
-            await sendThreadMessage(context.thread, `» **${username}:** Uploaded ${fileNames.join(', ')}`);
+            await sendThreadMessage(context.thread, `${QUEUE_PREFIX}**${username}:** Uploaded ${fileNames.join(', ')}`);
         }
         resolveContext(context, downloadedPaths);
         logger.log(`File upload completed for session ${context.sessionId}: ${downloadedPaths.length} files`);

package/dist/commands/fork-subagent.js

@@ -1,7 +1,7 @@
 // /fork-subagent command - Fork a subagent task session into a new thread.
 import { ActionRowBuilder, MessageFlags, StringSelectMenuBuilder, ThreadAutoArchiveDuration, } from 'discord.js';
 import { getSessionEventSnapshot, getThreadSession, setThreadSession, } from '../database.js';
-import { resolveTextChannel, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
+import { resolveTextChannel, resolveWorkingDirectory, sendThreadMessage, sendSessionPartBatches, } from '../discord-utils.js';
 import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { getDerivedSubagentSessions, } from '../session-handler/event-stream-state.js';
@@ -163,9 +163,7 @@ export async function handleForkSubagentSelectMenu(interaction) {
                 limit: 30,
             });
             const batched = batchChunksForDiscord(chunks);
-            for (const batch of batched) {
-                await sendThreadMessage(forkedThread, batch.content);
-            }
+            await sendSessionPartBatches({ thread: forkedThread, batches: batched });
         }
     }
     catch (error) {

package/dist/commands/fork.js

@@ -2,7 +2,7 @@
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import { getThreadSession, setThreadSession, setPartMessagesBatch, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, sendSessionPartBatches, } from '../discord-utils.js';
 import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -240,11 +240,11 @@ export async function handleForkSelectMenu(interaction) {
                 limit: 30,
             });
             const batched = batchChunksForDiscord(chunks);
-            for (const batch of batched) {
-                const discordMessage = await sendThreadMessage(thread, batch.content);
+            const sent = await sendSessionPartBatches({ thread, batches: batched });
+            for (const batch of sent) {
                 await setPartMessagesBatch(batch.partIds.map((partId) => ({
                     partId,
-                    messageId: discordMessage.id,
+                    messageId: batch.message.id,
                     threadId: thread.id,
                 })));
             }

package/dist/commands/last-sessions.js

@@ -104,16 +104,23 @@ export async function handleLastSessionsCommand({ command, }) {
     }
     const tableMarkdown = buildSessionTable({ rows });
     const segments = splitTablesFromMarkdown(tableMarkdown);
-    const allComponents = segments.flatMap((segment) => {
-        if (segment.type === 'components') {
-            return segment.components;
-        }
-        const textDisplay = {
-            type: ComponentType.TextDisplay,
-            content: segment.text,
-        };
-        return [textDisplay];
-    });
+    const btwNote = {
+        type: ComponentType.TextDisplay,
+        content: 'Titles prefixed `btw:` are side sessions that answer a related question. They are not duplicate sessions.',
+    };
+    const allComponents = [
+        btwNote,
+        ...segments.flatMap((segment) => {
+            if (segment.type === 'components') {
+                return segment.components;
+            }
+            const textDisplay = {
+                type: ComponentType.TextDisplay,
+                content: segment.text,
+            };
+            return [textDisplay];
+        }),
+    ];
     const { components } = truncateComponents(allComponents);
     await command.editReply({
         components,

package/dist/commands/merge-worktree.js

@@ -8,17 +8,23 @@ import { mergeWorktree, listBranchesByLastCommit, validateBranchRef, formatMerge
 import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, NothingToMergeError, } from '../errors.js';
+import { WORKTREE_PREFIX } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 function quoteShellArg(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
-/** Worktree thread title prefix - indicates unmerged worktree */
-export const WORKTREE_PREFIX = '⬦ ';
+export { WORKTREE_PREFIX };
+function worktreePrefixLength(name) {
+    if (name.startsWith(WORKTREE_PREFIX))
+        return WORKTREE_PREFIX.length;
+    return 0;
+}
 async function removeWorktreePrefixFromTitle(thread) {
-    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+    const prefixLength = worktreePrefixLength(thread.name);
+    if (!prefixLength) {
         return;
     }
-    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    const newName = thread.name.slice(prefixLength);
     const timeoutMs = 5000;
     await Promise.race([
         thread.setName(newName).catch((e) => {
@@ -120,8 +126,9 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             return;
         }
         if (result instanceof RebaseConflictError) {
-            const mergedThreadName = thread.name.startsWith(WORKTREE_PREFIX)
-                ? thread.name.slice(WORKTREE_PREFIX.length)
+            const prefixLength = worktreePrefixLength(thread.name);
+            const mergedThreadName = prefixLength
+                ? thread.name.slice(prefixLength)
                 : thread.name;
             const mergeCommand = [
                 'kimaki merge-worktree',

package/dist/commands/model-variant.js

@@ -138,11 +138,12 @@ export async function showModelVariantPicker({ channel, appId, editReply, }) {
     const { providerID, modelID, model: fullModelId } = currentModelInfo;
     const sourceLabel = formatSourceLabel(currentModelInfo);
     const variantLabel = cascadeVariant ? ` (${cascadeVariant})` : '';
-    const displayedModelId = resolveDisplayedModelId({
+    const displayedModelId = (await resolveDisplayedModelId({
         providers: providersResponse.data.all,
         providerID,
         modelID,
-    }) ?? fullModelId;
+        sessionID: sessionId,
+    })) ?? fullModelId;
     const provider = providersResponse.data.all.find((p) => {
         return p.id === providerID;
     });