kimaki 0.30.1 → 0.31.0

package/dist/agent-model.e2e.test.js

@@ -400,7 +400,7 @@ describe('agent model resolution', () => {
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         expect(footerMessage).toBeDefined();
@@ -444,7 +444,7 @@ describe('agent model resolution', () => {
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > system-context-ok
+        system-context-ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
     }, 15_000);
@@ -550,7 +550,7 @@ describe('agent model resolution', () => {
         Reply with exactly: channel-model-check
         --- from: assistant (TestBot)
         -# *using deterministic-provider/channel-model-v2*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
         expect(footerMessage).toBeDefined();
@@ -594,7 +594,7 @@ describe('agent model resolution', () => {
         Reply with exactly: variant-check
         --- from: assistant (TestBot)
         -# *using deterministic-provider/channel-model-v2*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
         expect(footer?.content).toContain(CHANNEL_MODEL);
@@ -655,13 +655,21 @@ describe('agent model resolution', () => {
         const forkedSessionModel = forkedSessionId
             ? await getSessionModel(forkedSessionId)
             : undefined;
+        // The immediate btw ack is edited in place with the fork link.
+        const sourceThreadText = (await discord.thread(sourceThread.id).text())
+            .replace(`<#${forkedThread.id}>`, '<#FORK_THREAD>');
+        expect(sourceThreadText.split('\n').slice(-3).join('\n')).toMatchInlineSnapshot(`
+        "Reply with exactly: btw-model-check. btw
+        --- from: assistant (TestBot)
+        Session forked! Continue in <#FORK_THREAD>"
+      `);
         const forkedThreadText = (await discord.thread(forkedThread.id).text())
             .replace(`<#${sourceThread.id}>`, '<#SOURCE_THREAD>');
         expect(forkedThreadText).toMatchInlineSnapshot(`
         "--- from: assistant (TestBot)
         Reusing context from <#SOURCE_THREAD> to answer prompt...
         Reply with exactly: btw-model-check
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
       `);
         expect(forkedSessionModel).toMatchInlineSnapshot(`
@@ -726,12 +734,12 @@ describe('agent model resolution', () => {
         Reply with exactly: first-thread-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         --- from: user (agent-model-tester)
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
@@ -780,7 +788,7 @@ describe('agent model resolution', () => {
         "--- from: assistant (TestBot)
         » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
         -# *using deterministic-provider/plan-model-v2 ⋅ plan*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
     }, 20_000);
@@ -816,7 +824,7 @@ describe('agent model resolution', () => {
         "--- from: assistant (TestBot)
         » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-variant-msg
         -# *using deterministic-provider/plan-model-v2 ⋅ plan*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         expect(sessionId ? await getSessionModel(sessionId) : undefined).toMatchInlineSnapshot(`
@@ -909,10 +917,10 @@ describe('agent model resolution', () => {
         Reply with exactly: inline-existing-first-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         » **agent-model-tester** (plan): Reply with exactly: inline-existing-plan-msg
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
     }, 20_000);
@@ -963,7 +971,7 @@ describe('agent model resolution', () => {
         Reply with exactly: switch-in-thread-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
@@ -971,7 +979,7 @@ describe('agent model resolution', () => {
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
@@ -1022,7 +1030,7 @@ describe('agent model resolution', () => {
         Reply with exactly: race-switch-first-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         --- from: user (agent-model-tester)
         Reply with exactly: race-switch-follow-up
@@ -1030,7 +1038,7 @@ describe('agent model resolution', () => {
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
@@ -1072,7 +1080,7 @@ describe('agent model resolution', () => {
         Reply with exactly: race-channel-follow-up
         --- from: assistant (TestBot)
         -# *using deterministic-provider/plan-model-v2 ⋅ plan*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const footer = [...(await discord.thread(thread.id).getMessages())]
@@ -1120,7 +1128,7 @@ describe('agent model resolution', () => {
         Reply with exactly: refresh-agent-model-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/plan-model-v2 ⋅ plan*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
         Using **plan** agent for this session
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
@@ -1162,7 +1170,7 @@ describe('agent model resolution', () => {
         Reply with exactly: channel-vs-agent-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
@@ -1204,7 +1212,7 @@ describe('agent model resolution', () => {
         Reply with exactly: plain-agent-override-msg
         --- from: assistant (TestBot)
         -# *using deterministic-provider/channel-model-v2*
-        > ok
+        ok
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
         Switched to **plain** agent for this session
         Model: *deterministic-provider/channel-model-v2* (channel override)

package/dist/analytics.js

@@ -1,4 +1,4 @@
-// Anonymous product analytics via Strada (OpenTelemetry).
+// Anonymous product analytics via Strada (@strada.sh/sdk, no dependencies).
 // Tracks install-level usage only: no Discord IDs, paths, prompts, or secrets.
 // A random install id is stored in {dataDir}/install-id for DAU-style queries.
 //
@@ -158,6 +158,8 @@ export function initAnalytics() {
             environment,
             version: getKimakiVersion(),
             userId: installId,
+            // Kimaki owns crash handling in discord-bot.ts; the SDK must not exit the process.
+            captureUncaughtErrors: false,
         });
         initialized = true;
     }

package/dist/btw-prefix-detection.js

@@ -6,10 +6,19 @@
 // - punctuation + btw: ". btw", "! btw", ". btw.", "!btw."
 // - btw as its own final line: "text\nbtw"
 // Non-matches: "btw fix this" (start only), "hello btw" (no punctuation)
+import { extractQueueSuffix } from './message-formatting.js';
 const BTW_SUFFIX_RE = /(?:[.!?,;:])\s*btw\.?\s*$|\n\s*btw\.?\s*$/i;
+const BTW_QUEUE_SUFFIX_RE = /(?:[.!?,;:])\s*btw\s+queue\.?\s*$|\n\s*btw\s+queue\.?\s*$/i;
 export function extractBtwSuffix(content) {
     if (!BTW_SUFFIX_RE.test(content)) {
         return { prompt: content, forceBtw: false };
     }
     return { prompt: content.replace(BTW_SUFFIX_RE, '').trimEnd(), forceBtw: true };
 }
+export function extractBtwQueueSuffix(content) {
+    const queued = BTW_QUEUE_SUFFIX_RE.test(content)
+        ? { prompt: content.replace(/\s+queue\.?\s*$/i, ''), forceQueue: true }
+        : extractQueueSuffix(content);
+    const btw = extractBtwSuffix(queued.prompt);
+    return { prompt: btw.prompt, forceQueue: queued.forceQueue, forceBtw: btw.forceBtw };
+}

package/dist/btw-prefix-detection.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { extractBtwSuffix } from './btw-prefix-detection.js';
+import { extractBtwSuffix, extractBtwQueueSuffix } from './btw-prefix-detection.js';
 describe('extractBtwSuffix', () => {
     test('matches after period', () => {
         expect(extractBtwSuffix('fix the bug. btw')).toMatchInlineSnapshot(`
@@ -91,3 +91,40 @@ describe('extractBtwSuffix', () => {
     `);
     });
 });
+test('btw queue suffix keeps both actions in order', () => {
+    expect([
+        'Explain this. btw queue',
+        'Explain this. btw. queue',
+        'Explain this\nbtw queue',
+        'Explain this. btw',
+        'Explain this. queue',
+    ].map(extractBtwQueueSuffix)).toMatchInlineSnapshot(`
+    [
+      {
+        "forceBtw": true,
+        "forceQueue": true,
+        "prompt": "Explain this",
+      },
+      {
+        "forceBtw": true,
+        "forceQueue": true,
+        "prompt": "Explain this",
+      },
+      {
+        "forceBtw": true,
+        "forceQueue": true,
+        "prompt": "Explain this",
+      },
+      {
+        "forceBtw": true,
+        "forceQueue": false,
+        "prompt": "Explain this",
+      },
+      {
+        "forceBtw": false,
+        "forceQueue": true,
+        "prompt": "Explain this",
+      },
+    ]
+  `);
+});

package/dist/cli-commands/send.js

@@ -37,7 +37,7 @@ cli
     .alias('start-session') // backwards compatibility
     .option('-c, --channel <channelId>', 'Discord channel ID')
     .option('-d, --project <path>', 'Project directory (alternative to --channel)')
-    .option('-p, --prompt <prompt>', 'Message content')
+    .option('-p, --prompt <prompt>', 'Message content. With --thread/--session, end with ". queue" to wait for the current run instead of interrupting it, ". btw" to fork a side session now, or ". btw queue" to fork after the current run')
     .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
     .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
     .option('--notify-only', 'Create notification thread without starting AI session')
@@ -55,7 +55,7 @@ cli
     .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
     .option('--pre-run <command>', 'Run a shell command in the project before starting a scheduled task')
     .option('--allow-concurrency', 'Allow concurrent sessions from the same scheduled task')
-    .option('--thread <threadId>', 'Post prompt to an existing thread')
+    .option('--thread <threadId>', 'Post prompt to an existing thread. Interrupts a busy session unless the prompt ends with ". queue"')
     .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
     .option('--parent-session <sessionId>', 'Parent OpenCode session ID for newly created child sessions')
     .option('--wait', 'Wait for session to complete, then print session text to stdout')

package/dist/cli-runner.js

@@ -9,6 +9,7 @@ import * as dbSchema from './schema.js';
 import { selectResolvedCommand } from './opencode-command.js';
 import { Events, ChannelType, Routes, AttachmentBuilder, } from 'discord.js';
 import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInternetReachableBaseUrl } from './discord-urls.js';
+import { extractBtwQueueSuffix } from './btw-prefix-detection.js';
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
@@ -160,6 +161,18 @@ function wrapPromptAttachmentText(prompt) {
     })
         .join('\n');
 }
+/**
+ * Visible message content + prompt.md text for prompts over Discord's limit.
+ * The bot reads queue/btw suffixes only from message content, so the suffix
+ * moves from the file to the visible message and the send still queues or forks.
+ */
+export function buildLongPromptMessage(prompt) {
+    const { prompt: fileText, forceQueue, forceBtw } = extractBtwQueueSuffix(prompt);
+    const preview = fileText.slice(0, 100).replace(/\n/g, ' ');
+    const summary = `Prompt attached as file (${fileText.length} chars)\n\n> ${preview}…`;
+    const suffix = [forceBtw && 'btw', forceQueue && 'queue'].filter(Boolean).join(' ');
+    return { content: suffix ? `${summary}\n\n${suffix}` : summary, fileText };
+}
 function promptAttachmentBlob(text) {
     return new Blob([new Uint8Array(Buffer.from(text, 'utf8'))], {
         type: 'text/markdown',
@@ -182,18 +195,18 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
         // When prompt exceeds Discord's limit, attach it as prompt.md alongside
         // user files so nothing is silently lost. Build prompt.md from memory so
         // parallel kimaki send processes never share or unlink a temp path.
-        const isLongPrompt = prompt.length > discordMaxLength;
-        const content = isLongPrompt
-            ? `Prompt attached as file (${prompt.length} chars)\n\n> ${prompt.slice(0, 100).replace(/\n/g, ' ')}...`
-            : prompt;
+        const longPrompt = prompt.length > discordMaxLength
+            ? buildLongPromptMessage(prompt)
+            : undefined;
+        const content = longPrompt ? longPrompt.content : prompt;
         const allFiles = files.map((file) => ({
             data: new Uint8Array(fs.readFileSync(file)),
             filename: path.basename(file),
             mimeType: mime.getType(file) || 'application/octet-stream',
         }));
-        if (isLongPrompt) {
+        if (longPrompt) {
             allFiles.push({
-                data: new Uint8Array(Buffer.from(prompt, 'utf8')),
+                data: new Uint8Array(Buffer.from(longPrompt.fileText, 'utf8')),
                 filename: 'prompt.md',
                 mimeType: 'text/markdown',
             });
@@ -259,17 +272,16 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
         }
         return firstMessage;
     }
-    const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
-    const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
+    const longPrompt = buildLongPromptMessage(prompt);
     // In-memory Blob only — no temp file. Parallel send must never share a path.
     const formData = new FormData();
     formData.append('payload_json', JSON.stringify({
-        content: summaryContent,
+        content: longPrompt.content,
         attachments: [{ id: 0, filename: 'prompt.md' }],
         embeds,
         allowed_mentions: { parse: store.getState().allowedMentions },
     }));
-    formData.append('files[0]', promptAttachmentBlob(wrapPromptAttachmentText(prompt)), 'prompt.md');
+    formData.append('files[0]', promptAttachmentBlob(wrapPromptAttachmentText(longPrompt.fileText)), 'prompt.md');
     const starterMessageResponse = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
         method: 'POST',
         headers: {

package/dist/cli-runner.test.js

@@ -1,6 +1,39 @@
 import { describe, expect, test } from 'vitest';
 import { REST } from 'discord.js';
-import { getOpenUrlCommand, isTransientNetworkError, resolveDiscordUserOption, } from './cli-runner.js';
+import { buildLongPromptMessage, getOpenUrlCommand, isTransientNetworkError, resolveDiscordUserOption, } from './cli-runner.js';
+import { extractBtwQueueSuffix } from './btw-prefix-detection.js';
+// Regression: a long `. btw` prompt lost its suffix and interrupted the source session.
+test('long prompts keep queue and btw suffixes in the visible message', () => {
+    const body = 'x'.repeat(2100);
+    expect(['queue', 'btw', 'btw queue', ''].map((suffix) => {
+        const { content, fileText } = buildLongPromptMessage(suffix ? `${body}. ${suffix}` : body);
+        const parsed = extractBtwQueueSuffix(content);
+        return { fileText: fileText === body, forceQueue: parsed.forceQueue, forceBtw: parsed.forceBtw };
+    })).toMatchInlineSnapshot(`
+    [
+      {
+        "fileText": true,
+        "forceBtw": false,
+        "forceQueue": true,
+      },
+      {
+        "fileText": true,
+        "forceBtw": true,
+        "forceQueue": false,
+      },
+      {
+        "fileText": true,
+        "forceBtw": true,
+        "forceQueue": true,
+      },
+      {
+        "fileText": true,
+        "forceBtw": false,
+        "forceQueue": false,
+      },
+    ]
+  `);
+});
 test('raw Discord user ID does not invent a username', async () => {
     const user = await resolveDiscordUserOption({
         user: '535922349652836367',

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

@@ -320,7 +320,7 @@ describe('kimaki send --channel thread creation', () => {
         thread empty content seed
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        > caught-by-model
+        caught-by-model
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)

package/dist/commands/btw.js

@@ -8,9 +8,19 @@ import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from
 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';
+import { copySessionPreferences } from './model.js';
+import { copySessionSystemPrompt } from '../system-message.js';
+import { OpenCodeSdkError } from '../errors.js';
+import { extractQueueSuffix } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.FORK);
+// Resolves to [value, elapsed ms] so each btw setup step can be logged.
+async function timed(promise) {
+    const start = Date.now();
+    const value = await promise;
+    return [value, Date.now() - start];
+}
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, sdkDirectory, prompt, modelPrompt = prompt, userId, username, appId, agent, images, }) {
+    const startedAt = Date.now();
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
     const [sessionId, getClientResult, textChannel] = await Promise.all([
         getThreadSession(sourceThread.id),
@@ -28,51 +38,106 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
     if (!textChannel) {
         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, directory: sdkDirectory });
-    if (!forkResponse.data) {
-        return new Error('Failed to fork session');
+    // Fork and thread creation are independent round trips, so run them together.
+    // If either side fails, remove whichever side succeeded.
+    const initMs = Date.now() - startedAt;
+    const [forkSettled, threadSettled] = await Promise.allSettled([
+        timed(getClientResult().session.fork({ sessionID: sessionId, directory: sdkDirectory })),
+        timed(textChannel.threads.create({
+            name: `btw: ${prompt}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `btw fork from session ${sessionId}`,
+        })),
+    ]);
+    const forkedSession = forkSettled.status === 'fulfilled' ? forkSettled.value[0].data : undefined;
+    const createdThread = threadSettled.status === 'fulfilled' ? threadSettled.value[0] : undefined;
+    const cleanup = async () => {
+        await Promise.all([
+            createdThread?.delete('btw fork setup failed').catch((error) => {
+                logger.warn(`Could not delete orphan btw thread ${createdThread.id}:`, error);
+            }),
+            forkedSession && getClientResult()
+                .session.delete({ sessionID: forkedSession.id, directory: sdkDirectory })
+                .catch((error) => {
+                logger.warn(`Could not delete orphan btw session ${forkedSession.id}:`, error);
+            }),
+        ]);
+    };
+    if (!forkedSession) {
+        await cleanup();
+        const cause = forkSettled.status === 'rejected' ? forkSettled.reason : forkSettled.value[0].error;
+        return new OpenCodeSdkError({ operation: 'session.fork', cause });
     }
-    const forkedSession = forkResponse.data;
-    const channelId = sourceThread.parentId || sourceThread.id;
-    await copyCurrentSessionModel({
-        sourceSessionId: sessionId,
-        targetSessionId: forkedSession.id,
-        channelId,
-        appId,
-        getClient: getClientResult,
-        directory: sdkDirectory,
-    });
-    const thread = await textChannel.threads.create({
-        name: `btw: ${prompt}`.slice(0, 100),
-        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-        reason: `btw fork from session ${sessionId}`,
-    });
-    // 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,
+    if (!createdThread) {
+        await cleanup();
+        return new Error('Failed to create the btw thread', {
+            cause: threadSettled.status === 'rejected' ? threadSettled.reason : undefined,
         });
     }
-    // Parallelize: member add and status message are independent best-effort actions
+    const thread = createdThread;
+    const forkMs = forkSettled.status === 'fulfilled' ? forkSettled.value[1] : -1;
+    const threadMs = threadSettled.status === 'fulfilled' ? threadSettled.value[1] : -1;
+    const channelId = sourceThread.parentId || sourceThread.id;
     const sourceThreadLink = `<#${sourceThread.id}>`;
+    // The fork must run with the source agent, model and pinned system prompt,
+    // so its request prefix is byte-identical and hits the source prompt cache.
+    // `false` (source not pinned yet) is the only fallback; I/O errors fail setup.
+    const copyStartedAt = Date.now();
+    const [, copiedSystem, history] = await Promise.all([
+        copySessionPreferences({
+            sourceSessionId: sessionId,
+            targetSessionId: forkedSession.id,
+            channelId,
+            appId,
+            getClient: getClientResult,
+            directory: sdkDirectory,
+        }),
+        copySessionSystemPrompt({
+            sourceSessionId: sessionId,
+            targetSessionId: forkedSession.id,
+        }),
+        getClientResult().session.messages({
+            sessionID: forkedSession.id,
+            directory: sdkDirectory,
+            limit: 10,
+        }).catch((cause) => new OpenCodeSdkError({ operation: 'session.messages', cause })),
+    ]);
+    if (copiedSystem instanceof Error) {
+        await cleanup();
+        return new Error(`Could not copy the source system prompt to the fork: ${copiedSystem.message}`, {
+            cause: copiedSystem,
+        });
+    }
+    const copyMs = Date.now() - copyStartedAt;
+    const routeStartedAt = Date.now();
     await Promise.all([
+        // DB mapping must complete before dispatch so the thread is routable
+        (async () => {
+            await setThreadSession(thread.id, forkedSession.id);
+            const sourceWorkspace = await getThreadWorktreeOrWorkspace(sourceThread.id);
+            if (sourceWorkspace?.status !== 'ready' || !sourceWorkspace.workspace_directory) {
+                return;
+            }
+            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,
+            });
+        })(),
         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})`);
+    const routeMs = Date.now() - routeStartedAt;
+    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId}), system prompt ${copiedSystem ? 'reused' : 'regenerated'}`);
+    logger.log(`[BTW TIMING] ${forkedSession.id} init=${initMs}ms fork=${forkMs}ms threadCreate=${threadMs}ms copyPrefs=${copyMs}ms route=${routeMs}ms total=${Date.now() - startedAt}ms`);
     // Parent context stays in the user prompt only. Do NOT pass parentSessionId
     // into enqueueIncoming: that would inject a parent block into the system
     // message and bust prompt cache shared with the parent session.
@@ -95,7 +160,18 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         appId,
         sessionId: forkedSession.id,
     });
-    await runtime.enqueueIncoming({
+    if (history instanceof Error || history.error) {
+        logger.warn('Could not load copied messages for btw cache diagnostics:', history);
+    }
+    else {
+        const last = history.data?.findLast(({ info }) => info.role === 'assistant' && typeof info.time.completed === 'number')?.info;
+        if (last?.role === 'assistant') {
+            runtime.seedForkPromptCacheBaseline(last);
+        }
+    }
+    // Not awaited: the caller confirms in the source thread right away while the
+    // runtime resolves preferences and dispatches. Failures are reported in the fork.
+    void runtime.enqueueIncoming({
         prompt: wrappedPrompt,
         agent,
         images,
@@ -103,7 +179,9 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, s
         username,
         appId,
         mode: 'opencode',
-    }).catch(async (error) => {
+    }).then(() => {
+        logger.log(`[BTW TIMING] ${forkedSession.id} promptAccepted=${Date.now() - startedAt}ms`);
+    }, 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.');
     });
@@ -131,7 +209,11 @@ export async function handleBtwCommand({ command, appId, }) {
         return;
     }
     const threadChannel = channel;
-    const prompt = command.options.getString('prompt', true);
+    const { prompt, forceQueue } = extractQueueSuffix(command.options.getString('prompt', true));
+    if (!prompt.trim()) {
+        await command.reply({ content: 'Write a question to fork', flags: MessageFlags.Ephemeral });
+        return;
+    }
     const resolved = await resolveWorkingDirectory({
         channel: threadChannel,
     });
@@ -145,6 +227,32 @@ export async function handleBtwCommand({ command, appId, }) {
     const { projectDirectory, workingDirectory } = resolved;
     await command.deferReply({ flags: MessageFlags.Ephemeral });
     try {
+        if (forceQueue) {
+            if (!await getThreadSession(threadChannel.id)) {
+                await command.editReply('No active session in this thread. Start a session, then retry /btw.');
+                return;
+            }
+            const runtime = getOrCreateRuntime({
+                threadId: threadChannel.id,
+                thread: threadChannel,
+                projectDirectory,
+                sdkDirectory: workingDirectory,
+                channelId: threadChannel.parentId || threadChannel.id,
+                appId,
+            });
+            const queued = await runtime.enqueueIncoming({
+                prompt,
+                queuedAction: 'btw',
+                userId: command.user.id,
+                username: command.user.displayName,
+                appId,
+                mode: 'local-queue',
+            });
+            await command.editReply(queued.queued
+                ? `Btw fork queued at position ${queued.position}. It will start after the earlier prompts finish.`
+                : 'Btw fork started. The new thread will appear shortly.');
+            return;
+        }
         const result = await forkSessionToBtwThread({
             sourceThread: threadChannel,
             projectDirectory,