kimaki 0.26.0 → 0.28.0

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({
@@ -487,14 +565,12 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
                 rest: command.client.rest,
             });
         }
-        const sessionDirectory = await (async () => {
-            if (!worktreePromise)
-                return projectDirectory;
-            const result = await worktreePromise;
-            if (result instanceof Error)
-                return projectDirectory;
-            return result;
-        })();
+        const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory;
+        if (worktreeResult instanceof Error) {
+            await command.editReply(`Worktree creation failed: ${worktreeResult.message}`);
+            return;
+        }
+        const sessionDirectory = worktreeResult;
         await command
             .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
             .catch(() => {
@@ -515,6 +591,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             agent: resolvedAgentName,
             appId,
             mode: 'opencode',
+            variant,
         });
     }
     else {
@@ -524,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

@@ -5,11 +5,14 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 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.
-// TTL prevents unbounded growth if user never answers a question.
-const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
+// No TTL on purpose: a question can only be answered by the user, so expiring it
+// could only abort the run. Cleanup happens on answer, on a new user message, on
+// abort (abortActiveRunInternal), and on thread dispose.
 export const pendingQuestionContexts = new Map();
 export function areAllQuestionsAnswered({ totalQuestions, answers, }) {
     for (let i = 0; i < totalQuestions; i++) {
@@ -75,32 +78,6 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
-    // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
-    // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
-    // made the model think the user chose an option when they didn't.
-    setTimeout(async () => {
-        const ctx = pendingQuestionContexts.get(contextHash);
-        if (!ctx) {
-            return;
-        }
-        // Delete context first so the dropdown becomes inert immediately.
-        // Without this, a user clicking during the abort() await would still
-        // be accepted by handleAskQuestionSelectMenu, then abort() would
-        // kill that valid run.
-        deletePendingQuestionContextsForRequest({
-            threadId: ctx.thread.id,
-            requestId: ctx.requestId,
-        });
-        // Abort the session so OpenCode isn't stuck waiting for a reply
-        const client = getOpencodeClient(ctx.directory);
-        if (client) {
-            await client.session.abort({
-                sessionID: ctx.sessionId,
-            }).catch((error) => {
-                logger.error('Failed to abort session after question expiry:', error);
-            });
-        }
-    }, QUESTION_CONTEXT_TTL_MS).unref();
     // Send one message per question with its dropdown directly underneath
     for (let i = 0; i < input.questions.length; i++) {
         const q = input.questions[i];
@@ -129,11 +106,24 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
             selectMenu.setMaxValues(options.length);
         }
         const actionRow = new ActionRowBuilder().addComponents(selectMenu);
-        await thread.send({
+        const sendResult = await thread.send({
             content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
             components: [actionRow],
             flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
-        });
+        }).catch((e) => new DiscordOperationError({ operation: 'sendQuestionDropdown', cause: e }));
+        // Without a visible dropdown the user can never answer, and there is no TTL
+        // to rescue the run, so drop the context and abort so OpenCode unblocks.
+        if (sendResult instanceof Error) {
+            logger.error('Failed to send question dropdown:', sendResult);
+            deletePendingQuestionContextsForRequest({ threadId: thread.id, requestId });
+            const client = getOpencodeClient(directory);
+            if (client) {
+                await client.session.abort({ sessionID: sessionId }).catch((error) => {
+                    logger.error('Failed to abort session after question send failure:', error);
+                });
+            }
+            return;
+        }
     }
     logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);
 }
@@ -194,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
@@ -276,7 +266,7 @@ export function parseAskUserQuestionTool(part) {
  *   the tool answer so the model sees the user's response. The caller should
  *   NOT also enqueue the message as a new prompt.
  *   Returns 'replied' on success, 'reply-failed' if the reply call fails
- *   (context kept pending so TTL can retry).
+ *   (context kept pending so the user can retry).
  */
 export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
@@ -320,7 +310,7 @@ export async function cancelPendingQuestion(threadId, userMessage) {
     }
     catch (error) {
         logger.error('Failed to answer question:', error);
-        // Keep context pending so TTL can still fire.
+        // Keep context pending so the user can retry.
         // Caller should not consume the user message since reply failed.
         return 'reply-failed';
     }

package/dist/commands/ask-question.test.js

@@ -1,8 +1,11 @@
 // Tests AskUserQuestion request deduplication and cleanup helpers.
 import { afterEach, describe, expect, test, vi } from 'vitest';
 import { areAllQuestionsAnswered, deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
-function createFakeThread() {
+function createFakeThread({ failSend } = {}) {
     const send = vi.fn(async () => {
+        if (failSend) {
+            throw new Error('Missing Permissions');
+        }
         return { id: 'msg-1' };
     });
     return {
@@ -88,6 +91,45 @@ describe('ask-question', () => {
         expect(removed).toBe(2);
         expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3']);
     });
+    test('does not schedule a question expiry timer', async () => {
+        const timeoutSpy = vi.spyOn(globalThis, 'setTimeout');
+        await showAskUserQuestionDropdowns({
+            thread: createFakeThread(),
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-no-ttl',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        expect(timeoutSpy).not.toHaveBeenCalled();
+    });
+    test('drops the context when the dropdown message fails to send', async () => {
+        await showAskUserQuestionDropdowns({
+            thread: createFakeThread({ failSend: true }),
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-send-fails',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        expect(pendingQuestionContexts.size).toBe(0);
+    });
     test('requires every question to have an answer', () => {
         expect(areAllQuestionsAnswered({
             totalQuestions: 3,

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,