kimaki 0.30.0 → 0.31.0

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,

package/dist/commands/context-usage.js

@@ -6,6 +6,45 @@ import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.j
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.SESSION);
+export function formatContextBreakdown({ messages, lastAssistantId, inputTokens, }) {
+    if (inputTokens <= 0)
+        return undefined;
+    const lastIndex = messages.findIndex((message) => message.info.id === lastAssistantId);
+    if (lastIndex < 0)
+        return undefined;
+    const history = messages.slice(0, lastIndex);
+    const compactIndex = history.findLastIndex((message) => message.parts.some((part) => part.type === 'compaction'));
+    const active = history.slice(compactIndex < 0 ? 0 : compactIndex + 1);
+    const system = [...active].reverse().find((message) => message.info.role === 'user' && message.info.system);
+    const systemChars = system?.info.role === 'user' ? system.info.system?.length ?? 0 : 0;
+    const toolChars = new Map();
+    for (const message of active) {
+        if (message.info.role !== 'assistant')
+            continue;
+        for (const part of message.parts) {
+            if (part.type !== 'tool')
+                continue;
+            const output = part.state.status === 'completed' && !part.state.time.compacted
+                ? part.state.output
+                : part.state.status === 'error' ? part.state.error : '';
+            const chars = JSON.stringify(part.state.input).length + output.length;
+            toolChars.set(part.tool, (toolChars.get(part.tool) ?? 0) + chars);
+        }
+    }
+    const estimates = [
+        { name: 'system', tokens: Math.ceil(systemChars / 4) },
+        ...[...toolChars].map(([name, chars]) => ({ name: `tool ${name}`, tokens: Math.ceil(chars / 4) })),
+    ].sort((a, b) => b.tokens - a.tokens);
+    const estimated = estimates.reduce((total, entry) => total + entry.tokens, 0);
+    const scale = estimated > inputTokens ? inputTokens / estimated : 1;
+    const visible = estimates.slice(0, 5).map((entry) => ({
+        name: entry.name,
+        tokens: Math.floor(entry.tokens * scale),
+    }));
+    const other = inputTokens - visible.reduce((total, entry) => total + entry.tokens, 0);
+    const format = ({ name, tokens }) => `${name} ${(tokens / inputTokens * 100).toFixed(1)}% (${tokens.toLocaleString('en-US')})`;
+    return `**Estimated input mix:** ${[...visible.filter((entry) => entry.tokens > 0), { name: 'other', tokens: other }].map(format).join(' · ')} tokens (other includes messages and unexposed prompts)`;
+}
 function getTokenTotal({ input, output, reasoning, cache, }) {
     return input + output + reasoning + cache.read + cache.write;
 }
@@ -96,6 +135,7 @@ export async function handleContextUsageCommand({ command, }) {
         }
         const { tokens, modelID, providerID } = lastAssistant.info;
         const totalTokens = getTokenTotal(tokens);
+        const inputTokens = tokens.input + tokens.cache.read + tokens.cache.write;
         // Sum cost across all assistant messages for accurate session total
         // (AssistantMessage.cost is per-message, not cumulative)
         const totalCost = assistantMessages.reduce((sum, m) => {
@@ -129,6 +169,13 @@ export async function handleContextUsageCommand({ command, }) {
         else {
             lines.push(`**Context usage:** ${formattedTokens} tokens (context limit unavailable)`);
         }
+        const breakdown = formatContextBreakdown({
+            messages,
+            lastAssistantId: lastAssistant.info.id,
+            inputTokens,
+        });
+        if (breakdown)
+            lines.push(breakdown);
         if (modelID) {
             lines.push(`**Model:** ${modelID}`);
         }

package/dist/commands/context-usage.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import { formatContextBreakdown } from './context-usage.js';
+const part = (messageID, value) => ({
+    id: `part-${messageID}`,
+    sessionID: 'session',
+    messageID,
+    ...value,
+});
+const user = (id, system) => ({
+    id, sessionID: 'session', role: 'user', time: { created: 1 },
+    agent: 'build', model: { providerID: 'test', modelID: 'test' }, system,
+});
+const assistant = (id, input) => ({
+    id, sessionID: 'session', role: 'assistant', time: { created: 2 },
+    parentID: 'user', modelID: 'test', providerID: 'test', mode: 'build',
+    agent: 'build', path: { cwd: '/', root: '/' }, cost: 0,
+    tokens: { input, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+});
+describe('formatContextBreakdown', () => {
+    test('attributes tool call inputs and outputs by type, and excludes the response to the measured prompt', () => {
+        const messages = [
+            { info: user('user', 's'.repeat(40)), parts: [part('user', { type: 'text', text: 'u'.repeat(20) })] },
+            { info: assistant('first', 20), parts: [
+                    part('first', { type: 'tool', tool: 'read', callID: 'call', state: {
+                            status: 'completed', input: { filePath: 'a'.repeat(28) }, output: 'o'.repeat(40),
+                            title: 'read', metadata: {}, time: { start: 1, end: 2 },
+                        } }),
+                ] },
+            { info: assistant('last', 50), parts: [part('last', { type: 'text', text: 'x'.repeat(800) })] },
+        ];
+        expect(formatContextBreakdown({ messages, lastAssistantId: 'last', inputTokens: 50 }))
+            .toMatchInlineSnapshot(`"**Estimated input mix:** tool read 42.0% (21) · system 20.0% (10) · other 38.0% (19) tokens (other includes messages and unexposed prompts)"`);
+    });
+    test('ignores compacted history and old tool outputs', () => {
+        const messages = [
+            { info: user('old', 'x'.repeat(800)), parts: [part('old', { type: 'text', text: 'x'.repeat(800) })] },
+            { info: assistant('old-answer', 30), parts: [part('old-answer', { type: 'tool', tool: 'bash', callID: 'old', state: {
+                            status: 'completed', input: {}, output: 'x'.repeat(800), title: 'old', metadata: {},
+                            time: { start: 1, end: 2, compacted: 3 },
+                        } })] },
+            { info: user('compact'), parts: [part('compact', { type: 'compaction', auto: true })] },
+            { info: assistant('summary', 20), parts: [part('summary', { type: 'text', text: 'summary'.repeat(8) })] },
+            { info: user('new', 's'.repeat(20)), parts: [part('new', { type: 'text', text: 'u'.repeat(20) })] },
+            { info: assistant('last', 40), parts: [] },
+        ];
+        expect(formatContextBreakdown({ messages, lastAssistantId: 'last', inputTokens: 40 }))
+            .toMatchInlineSnapshot(`"**Estimated input mix:** system 12.5% (5) · other 87.5% (35) tokens (other includes messages and unexposed prompts)"`);
+    });
+});

package/dist/commands/fork.js

@@ -5,6 +5,8 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, sendSessionPartBatches, } from '../discord-utils.js';
 import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { copySessionPreferences } from './model.js';
+import { copySessionSystemPrompt } from '../system-message.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
 const forkLogger = createLogger(LogPrefix.FORK);
@@ -224,7 +226,36 @@ export async function handleForkSelectMenu(interaction) {
         });
         // Claim the forked session immediately so external polling does not race
         // and create a duplicate Sync thread before the rest of this setup runs.
-        await setThreadSession(thread.id, forkedSession.id);
+        // Same agent, model and pinned system prompt keep the source prompt cache.
+        const [, , copiedSystem] = await Promise.all([
+            setThreadSession(thread.id, forkedSession.id),
+            copySessionPreferences({
+                sourceSessionId: sessionId,
+                targetSessionId: forkedSession.id,
+                channelId: textChannel.id,
+                appId: interaction.applicationId,
+                getClient,
+                directory: projectDirectory,
+            }),
+            copySessionSystemPrompt({
+                sourceSessionId: sessionId,
+                targetSessionId: forkedSession.id,
+            }),
+        ]);
+        // `false` (source not pinned yet) is the only fallback; I/O errors fail setup.
+        if (copiedSystem instanceof Error) {
+            forkLogger.error(`Could not pin source system prompt on fork ${forkedSession.id}:`, copiedSystem);
+            await Promise.all([
+                thread.delete('fork setup failed').catch((error) => {
+                    forkLogger.warn(`Could not delete orphan fork thread ${thread.id}:`, error);
+                }),
+                getClient().session.delete({ sessionID: forkedSession.id }).catch((error) => {
+                    forkLogger.warn(`Could not delete orphan fork session ${forkedSession.id}:`, error);
+                }),
+            ]);
+            await interaction.editReply(`Failed to fork session: could not copy the source system prompt (${copiedSystem.message})`);
+            return;
+        }
         // Add user to thread so it appears in their sidebar
         await thread.members.add(interaction.user.id);
         const sourceThreadLink = `<#${threadChannel.id}>`;

package/dist/commands/model.js

@@ -6,9 +6,11 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getDefaultModel, resolveDisplayedModelId, } from '../session-handler/model-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { resolveAgentPreference } from '../session-handler/agent-utils.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { OpenCodeSdkError } from '../errors.js';
 import * as errore from 'errore';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
@@ -123,27 +125,80 @@ export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, a
     });
     modelLogger.log(`[MODEL] Snapshotted session model ${bootstrappedModel.model} for session ${sessionId}`);
 }
-export async function copyCurrentSessionModel({ sourceSessionId, targetSessionId, channelId, appId, getClient, directory, }) {
-    const modelInfo = await getCurrentModelInfo({
-        sessionId: sourceSessionId,
-        channelId,
-        appId,
-        getClient,
-        directory,
-    });
+const LAST_USER_AGENT_PAGE_SIZE = 50;
+const LAST_USER_AGENT_MAX_PAGES = 10;
+/**
+ * Agent of the newest user message in a session, paging back from the end.
+ * Long agentic turns hold many assistant messages after one user message.
+ */
+async function getLastUserMessageAgent({ getClient, sessionId, directory, before, page = 0, }) {
+    if (page >= LAST_USER_AGENT_MAX_PAGES)
+        return undefined;
+    const response = await (async () => {
+        return getClient().session.messages({
+            sessionID: sessionId,
+            directory,
+            limit: LAST_USER_AGENT_PAGE_SIZE,
+            before,
+        });
+    })().catch((cause) => new OpenCodeSdkError({ operation: 'session.messages', cause }));
+    if (response instanceof Error)
+        return response;
+    if (response.error || !response.data) {
+        return new OpenCodeSdkError({ operation: 'session.messages', cause: response.error });
+    }
+    const newestUser = response.data
+        .map((message) => message.info)
+        .filter((info) => info.role === 'user')
+        .sort((a, b) => b.time.created - a.time.created)[0];
+    if (newestUser?.role === 'user')
+        return newestUser.agent;
+    const cursor = response.response.headers.get('X-Next-Cursor');
+    if (!cursor)
+        return undefined;
+    return getLastUserMessageAgent({ getClient, sessionId, directory, before: cursor, page: page + 1 });
+}
+/**
+ * Copy the agent, model and variant onto a forked session. The fork must run
+ * the same agent and model as the source: a different agent changes tools and
+ * prompts, which busts the prompt cache. The agent comes from the fork's own
+ * history (the fork point, also right for /fork at an earlier message), with
+ * the source DB preference as fallback.
+ */
+export async function copySessionPreferences({ sourceSessionId, targetSessionId, channelId, appId, getClient, directory, }) {
+    const [historyAgent, preferredAgent, modelInfo, variant] = await Promise.all([
+        getClient instanceof Error
+            ? undefined
+            : getLastUserMessageAgent({ getClient, sessionId: targetSessionId, directory }),
+        resolveAgentPreference({ sessionId: sourceSessionId, channelId }),
+        getCurrentModelInfo({
+            sessionId: sourceSessionId,
+            channelId,
+            appId,
+            getClient,
+            directory,
+        }),
+        getVariantCascade({
+            sessionId: sourceSessionId,
+            channelId,
+            appId,
+        }),
+    ]);
+    if (historyAgent instanceof Error) {
+        modelLogger.warn(`[MODEL] Could not read fork history agent for ${targetSessionId}, using DB preference: ${historyAgent.message}`);
+    }
+    const agent = (historyAgent instanceof Error ? undefined : historyAgent) || preferredAgent;
+    if (agent) {
+        await setSessionAgent(targetSessionId, agent);
+    }
     if (modelInfo.type === 'none')
         return;
-    const variant = await getVariantCascade({
-        sessionId: sourceSessionId,
-        channelId,
-        appId,
-    });
     await setSessionModel({
         sessionId: targetSessionId,
         modelId: modelInfo.model,
         variant: variant ?? null,
     });
-    modelLogger.log(`[MODEL] Copied session model ${modelInfo.model} from ${sourceSessionId} to ${targetSessionId}`);
+    modelLogger.log(`[MODEL] Copied session agent ${agent ?? 'default'} and model ${modelInfo.model} from ${sourceSessionId} to ${targetSessionId}`);
 }
 /**
  * Get the current model info for a channel/session, including where it comes from.

package/dist/commands/new-worktree.js

@@ -15,7 +15,7 @@ import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
-import { copyCurrentSessionModel } from './model.js';
+import { copySessionPreferences } from './model.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
     if (!rawBaseBranch) {
@@ -551,7 +551,10 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
                 await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
                 return;
             }
-            await copyCurrentSessionModel({
+            // No system prompt copy: OpenCode's env block (cwd) precedes the kimaki
+            // system prompt, so a fork into another directory never shares the
+            // source cache prefix. The fork pins its own prompt on its first turn.
+            await copySessionPreferences({
                 sourceSessionId,
                 targetSessionId: forkedSession.id,
                 channelId: parent.id,