kimaki 0.16.0 → 0.17.0

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

@@ -19,7 +19,7 @@ import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provid
 import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
-import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionAgent, getChannelAgent, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionModel, getSessionAgent, getChannelAgent, setSessionModel, } from './database.js';
 import { getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
@@ -213,6 +213,9 @@ describe('agent model resolution', () => {
         });
         // Add extra models to the provider so opencode accepts them
         const providerConfig = opencodeConfig.provider[PROVIDER_NAME];
+        if (!providerConfig) {
+            throw new Error(`Missing deterministic provider config for ${PROVIDER_NAME}`);
+        }
         providerConfig.models[AGENT_MODEL] = { name: AGENT_MODEL };
         providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL };
         providerConfig.models[CHANNEL_MODEL] = { name: CHANNEL_MODEL };
@@ -532,6 +535,76 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
+    test('/btw fork keeps source session model when channel model differs', async () => {
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: btw-source-msg',
+        });
+        const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: btw-source-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: sourceThread.id,
+            timeout: 6_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const sourceSessionId = await getThreadSession(sourceThread.id);
+        expect(sourceSessionId).toBeDefined();
+        if (!sourceSessionId)
+            throw new Error('Expected source session');
+        await setSessionModel({
+            sessionId: sourceSessionId,
+            modelId: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
+        });
+        await setChannelModel({
+            channelId: TEXT_CHANNEL_ID,
+            modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+        });
+        await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: btw-model-check. btw',
+        });
+        const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'btw: Reply with exactly: btw-model-check';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: forkedThread.id,
+            timeout: 6_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const forkedSessionId = await getThreadSession(forkedThread.id);
+        expect(forkedSessionId).toBeDefined();
+        const forkedSessionModel = forkedSessionId
+            ? await getSessionModel(forkedSessionId)
+            : undefined;
+        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
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
+      `);
+        expect(forkedSessionModel).toMatchInlineSnapshot(`
+        {
+          "modelId": "deterministic-provider/plan-model-v2",
+          "variant": null,
+        }
+      `);
+        expect(forkedSessionModel?.modelId).not.toBe(`${PROVIDER_NAME}/${CHANNEL_MODEL}`);
+    }, 20_000);
     test('changing channel agent via /plan-agent does not affect existing thread model', async () => {
         // 1. Set channel agent to test-agent (uses AGENT_MODEL)
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');

package/dist/commands/btw.js

@@ -8,6 +8,7 @@ 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';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
@@ -33,6 +34,15 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         return new Error('Failed to fork session');
     }
     const forkedSession = forkResponse.data;
+    const channelId = sourceThread.parentId || sourceThread.id;
+    await copyCurrentSessionModel({
+        sourceSessionId: sessionId,
+        targetSessionId: forkedSession.id,
+        channelId,
+        appId,
+        getClient: getClientResult,
+        directory: projectDirectory,
+    });
     const thread = await textChannel.threads.create({
         name: `btw: ${prompt}`.slice(0, 100),
         autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
@@ -53,8 +63,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         `Do NOT continue, resume, or reference the previous task. Only answer the question below.`,
         ``,
         `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
-        `If the user asks you to send a message or follow-up to the parent session, use:`,
-        `  kimaki send --session ${sessionId} --prompt 'your message here'`,
+        `Do NOT send messages to the parent session unless the user explicitly asks you to.`,
         ``,
         prompt,
     ].join('\n');
@@ -63,7 +72,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         thread,
         projectDirectory,
         sdkDirectory: projectDirectory,
-        channelId: sourceThread.parentId || sourceThread.id,
+        channelId,
         appId,
     });
     await runtime.enqueueIncoming({

package/dist/commands/merge-worktree.js

@@ -9,7 +9,7 @@ import { notifyError } from '../sentry.js';
 import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
 import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
-import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, } from '../errors.js';
+import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, NothingToMergeError, } from '../errors.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 /** Worktree thread title prefix - indicates unmerged worktree */
 export const WORKTREE_PREFIX = '⬦ ';
@@ -103,6 +103,11 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             await command.editReply('Merge failed: uncommitted changes in main. Commit changes in the main worktree first, then run `/merge-worktree` again.');
             return;
         }
+        if (result instanceof NothingToMergeError) {
+            void removeWorktreePrefixFromTitle(thread);
+            await command.editReply(`Merge failed: ${result.message}`);
+            return;
+        }
         if (result instanceof RebaseConflictError) {
             await command.editReply('Rebase conflict detected. Asking the model to resolve...');
             await sendPromptToModel({

package/dist/commands/model.js

@@ -104,6 +104,28 @@ 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,
+    });
+    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}`);
+}
 /**
  * Get the current model info for a channel/session, including where it comes from.
  * Priority: session > agent > channel > global > opencode default
@@ -196,16 +218,11 @@ export async function handleModelCommand({ interaction, appId, }) {
         return;
     }
     // Determine if we're in a thread or text channel
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
+    const thread = channel.isThread() ? channel : undefined;
     let projectDirectory;
     let targetChannelId;
     let sessionId;
-    if (isThread) {
-        const thread = channel;
+    if (thread) {
         // Parallelize: resolve metadata and session ID at the same time
         const [textChannel, threadSessionId] = await Promise.all([
             resolveTextChannel(thread),
@@ -240,7 +257,7 @@ export async function handleModelCommand({ interaction, appId, }) {
             return;
         }
         const effectiveAppId = appId;
-        if (isThread && sessionId) {
+        if (thread && sessionId) {
             await ensureSessionPreferencesSnapshot({
                 sessionId,
                 channelId: targetChannelId,
@@ -313,8 +330,8 @@ export async function handleModelCommand({ interaction, appId, }) {
             dir: projectDirectory,
             channelId: targetChannelId,
             sessionId: sessionId,
-            isThread: isThread,
-            thread: isThread ? channel : undefined,
+            isThread: Boolean(thread),
+            thread,
             appId,
             providerSelectHeader,
         };

package/dist/commands/new-worktree.js

@@ -13,6 +13,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';
 const logger = createLogger(LogPrefix.WORKTREE);
 const DEFAULT_WORKTREE_BASE_REF = 'HEAD';
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
@@ -434,6 +435,14 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
             await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
             return;
         }
+        await copyCurrentSessionModel({
+            sourceSessionId,
+            targetSessionId: forkedSession.id,
+            channelId: parent.id,
+            appId,
+            getClient,
+            directory: projectDirectory,
+        });
         const permissionResponse = await getClient().session.update({
             sessionID: forkedSession.id,
             directory: result,

package/dist/db.test.js

@@ -7,9 +7,10 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, createPendingWorktree, getSessionEventSnapshot, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorktree, getSessionEventSnapshot, getSessionModel, setSessionModel, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
+import { copyCurrentSessionModel } from './commands/model.js';
 afterAll(async () => {
     await closeDb();
 });
@@ -100,6 +101,31 @@ describe('getDb', () => {
         await db.delete(schema.thread_worktrees).where(orm.eq(schema.thread_worktrees.thread_id, threadId));
         await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
     });
+    test('copyCurrentSessionModel snapshots source session model to forked session', async () => {
+        const db = await getDb();
+        const sourceSessionId = `test-source-session-${crypto.randomUUID()}`;
+        const targetSessionId = `test-target-session-${crypto.randomUUID()}`;
+        const getClient = (() => {
+            throw new Error('provider lookup should not run for explicit session models');
+        });
+        await setSessionModel({
+            sessionId: sourceSessionId,
+            modelId: 'anthropic/claude-opus-4-6',
+            variant: 'thinking',
+        });
+        await copyCurrentSessionModel({
+            sourceSessionId,
+            targetSessionId,
+            getClient,
+        });
+        await expect(getSessionModel(targetSessionId)).resolves.toMatchInlineSnapshot(`
+      {
+        "modelId": "anthropic/claude-opus-4-6",
+        "variant": "thinking",
+      }
+    `);
+        await db.delete(schema.session_models).where(orm.inArray(schema.session_models.session_id, [sourceSessionId, targetSessionId]));
+    });
     test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
         const db = await getDb();
         const threadId = 'test-session-events-thread';

package/dist/opencode.js

@@ -529,6 +529,26 @@ async function startSingleServer({ directory, } = {}) {
         experimental: {
             continue_loop_on_deny: true,
         },
+        provider: {
+            xai: {
+                models: {
+                    'grok-composer-2.5-fast': {
+                        name: 'Grok Composer 2.5 Fast',
+                        attachment: true,
+                        tool_call: true,
+                        limit: {
+                            context: 256000,
+                            output: 256000,
+                        },
+                        cost: {
+                            input: 0.50,
+                            output: 2.50,
+                            cache_read: 0.20,
+                        },
+                    },
+                },
+            },
+        },
         skills: {
             paths: [path.resolve(__dirname, '..', 'skills')],
         },

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -63,9 +63,9 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
+    "libsqlproxy": "^0.1.0",
     "opencode-injection-guard": "^0.2.1",
-    "traforo": "^0.7.0",
-    "libsqlproxy": "^0.1.0"
+    "traforo": "^0.7.1"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",

package/src/agent-model.e2e.test.ts

@@ -39,8 +39,10 @@ import {
   setChannelAgent,
   setChannelModel,
   getThreadSession,
+  getSessionModel,
   getSessionAgent,
   getChannelAgent,
+  setSessionModel,
   type VerbosityLevel,
 } from './database.js'
 import { getDb } from './db.js'
@@ -281,8 +283,9 @@ describe('agent model resolution', () => {
     })
 
     // Add extra models to the provider so opencode accepts them
-    const providerConfig = opencodeConfig.provider[PROVIDER_NAME] as {
-      models: Record<string, { name: string }>
+    const providerConfig = opencodeConfig.provider[PROVIDER_NAME]
+    if (!providerConfig) {
+      throw new Error(`Missing deterministic provider config for ${PROVIDER_NAME}`)
     }
     providerConfig.models[AGENT_MODEL] = { name: AGENT_MODEL }
     providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL }
@@ -700,6 +703,91 @@ describe('agent model resolution', () => {
     15_000,
   )
 
+  test(
+    '/btw fork keeps source session model when channel model differs',
+    async () => {
+      const db = await getDb()
+      await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID))
+      await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID))
+
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: btw-source-msg',
+      })
+
+      const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: btw-source-msg'
+        },
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: sourceThread.id,
+        timeout: 6_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const sourceSessionId = await getThreadSession(sourceThread.id)
+      expect(sourceSessionId).toBeDefined()
+      if (!sourceSessionId) throw new Error('Expected source session')
+
+      await setSessionModel({
+        sessionId: sourceSessionId,
+        modelId: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
+      })
+      await setChannelModel({
+        channelId: TEXT_CHANNEL_ID,
+        modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+      })
+
+      await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: btw-model-check. btw',
+      })
+
+      const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'btw: Reply with exactly: btw-model-check'
+        },
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: forkedThread.id,
+        timeout: 6_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const forkedSessionId = await getThreadSession(forkedThread.id)
+      expect(forkedSessionId).toBeDefined()
+      const forkedSessionModel = forkedSessionId
+        ? await getSessionModel(forkedSessionId)
+        : undefined
+
+      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
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
+      `)
+      expect(forkedSessionModel).toMatchInlineSnapshot(`
+        {
+          "modelId": "deterministic-provider/plan-model-v2",
+          "variant": null,
+        }
+      `)
+      expect(forkedSessionModel?.modelId).not.toBe(`${PROVIDER_NAME}/${CHANNEL_MODEL}`)
+    },
+    20_000,
+  )
+
   test(
     'changing channel agent via /plan-agent does not affect existing thread model',
     async () => {

package/src/commands/btw.ts

@@ -19,6 +19,7 @@ import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js
 import { createLogger, LogPrefix } from '../logger.js'
 import type { CommandContext } from './types.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
+import { copyCurrentSessionModel } from './model.js'
 
 const logger = createLogger(LogPrefix.FORK)
 
@@ -62,6 +63,16 @@ export async function forkSessionToBtwThread({
     return new Error('Failed to fork session')
   }
   const forkedSession = forkResponse.data
+  const channelId = sourceThread.parentId || sourceThread.id
+
+  await copyCurrentSessionModel({
+    sourceSessionId: sessionId,
+    targetSessionId: forkedSession.id,
+    channelId,
+    appId,
+    getClient: getClientResult,
+    directory: projectDirectory,
+  })
 
   const thread = await textChannel.threads.create({
     name: `btw: ${prompt}`.slice(0, 100),
@@ -92,8 +103,7 @@ export async function forkSessionToBtwThread({
     `Do NOT continue, resume, or reference the previous task. Only answer the question below.`,
     ``,
     `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
-    `If the user asks you to send a message or follow-up to the parent session, use:`,
-    `  kimaki send --session ${sessionId} --prompt 'your message here'`,
+    `Do NOT send messages to the parent session unless the user explicitly asks you to.`,
     ``,
     prompt,
   ].join('\n')
@@ -103,7 +113,7 @@ export async function forkSessionToBtwThread({
     thread,
     projectDirectory,
     sdkDirectory: projectDirectory,
-    channelId: sourceThread.parentId || sourceThread.id,
+    channelId,
     appId,
   })
   await runtime.enqueueIncoming({

package/src/commands/merge-worktree.ts

@@ -25,6 +25,7 @@ import {
   RebaseConflictError,
   DirtyWorktreeError,
   TargetDirtyWorktreeError,
+  NothingToMergeError,
 } from '../errors.js'
 
 const logger = createLogger(LogPrefix.WORKTREE)
@@ -160,6 +161,12 @@ export async function handleMergeWorktreeCommand({
       return
     }
 
+    if (result instanceof NothingToMergeError) {
+      void removeWorktreePrefixFromTitle(thread)
+      await command.editReply(`Merge failed: ${result.message}`)
+      return
+    }
+
     if (result instanceof RebaseConflictError) {
       await command.editReply(
         'Rebase conflict detected. Asking the model to resolve...',

package/src/commands/model.ts

@@ -248,6 +248,45 @@ export async function ensureSessionPreferencesSnapshot({
   )
 }
 
+export async function copyCurrentSessionModel({
+  sourceSessionId,
+  targetSessionId,
+  channelId,
+  appId,
+  getClient,
+  directory,
+}: {
+  sourceSessionId: string
+  targetSessionId: string
+  channelId?: string
+  appId?: string
+  getClient: Awaited<ReturnType<typeof initializeOpencodeForDirectory>>
+  directory?: string
+}) {
+  const modelInfo = await getCurrentModelInfo({
+    sessionId: sourceSessionId,
+    channelId,
+    appId,
+    getClient,
+    directory,
+  })
+  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}`,
+  )
+}
+
 /**
  * Get the current model info for a channel/session, including where it comes from.
  * Priority: session > agent > channel > global > opencode default
@@ -372,18 +411,13 @@ export async function handleModelCommand({
   }
 
   // Determine if we're in a thread or text channel
-  const isThread = [
-    ChannelType.PublicThread,
-    ChannelType.PrivateThread,
-    ChannelType.AnnouncementThread,
-  ].includes(channel.type)
+  const thread = channel.isThread() ? channel : undefined
 
   let projectDirectory: string | undefined
   let targetChannelId: string
   let sessionId: string | undefined
 
-  if (isThread) {
-    const thread = channel as ThreadChannel
+  if (thread) {
     // Parallelize: resolve metadata and session ID at the same time
     const [textChannel, threadSessionId] = await Promise.all([
       resolveTextChannel(thread),
@@ -420,7 +454,7 @@ export async function handleModelCommand({
 
     const effectiveAppId = appId
 
-    if (isThread && sessionId) {
+    if (thread && sessionId) {
       await ensureSessionPreferencesSnapshot({
         sessionId,
         channelId: targetChannelId,
@@ -503,8 +537,8 @@ export async function handleModelCommand({
       dir: projectDirectory,
       channelId: targetChannelId,
       sessionId: sessionId,
-      isThread: isThread,
-      thread: isThread ? (channel as ThreadChannel) : undefined,
+      isThread: Boolean(thread),
+      thread,
       appId,
       providerSelectHeader,
     }

package/src/commands/new-worktree.ts

@@ -43,6 +43,7 @@ import {
 import { WORKTREE_PREFIX } from './merge-worktree.js'
 import type { AutocompleteContext } from './types.js'
 import * as errore from 'errore'
+import { copyCurrentSessionModel } from './model.js'
 
 const logger = createLogger(LogPrefix.WORKTREE)
 const DEFAULT_WORKTREE_BASE_REF = 'HEAD'
@@ -598,6 +599,15 @@ async function handleWorktreeInThread({
         return
       }
 
+      await copyCurrentSessionModel({
+        sourceSessionId,
+        targetSessionId: forkedSession.id,
+        channelId: parent.id,
+        appId,
+        getClient,
+        directory: projectDirectory,
+      })
+
       const permissionResponse = await getClient().session.update({
         sessionID: forkedSession.id,
         directory: result,

package/src/db.test.ts

@@ -12,9 +12,13 @@ import {
   appendSessionEventsSinceLastTimestamp,
   createPendingWorktree,
   getSessionEventSnapshot,
+  getSessionModel,
+  setSessionModel,
 } from './database.js'
 import { startHranaServer, stopHranaServer } from './hrana-server.js'
 import { chooseLockPort } from './test-utils.js'
+import { copyCurrentSessionModel } from './commands/model.js'
+import type { initializeOpencodeForDirectory } from './opencode.js'
 
 afterAll(async () => {
   await closeDb()
@@ -118,6 +122,36 @@ describe('getDb', () => {
     await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId))
   })
 
+  test('copyCurrentSessionModel snapshots source session model to forked session', async () => {
+    const db = await getDb()
+    const sourceSessionId = `test-source-session-${crypto.randomUUID()}`
+    const targetSessionId = `test-target-session-${crypto.randomUUID()}`
+    const getClient = (() => {
+      throw new Error('provider lookup should not run for explicit session models')
+    }) satisfies Exclude<Awaited<ReturnType<typeof initializeOpencodeForDirectory>>, Error>
+
+    await setSessionModel({
+      sessionId: sourceSessionId,
+      modelId: 'anthropic/claude-opus-4-6',
+      variant: 'thinking',
+    })
+
+    await copyCurrentSessionModel({
+      sourceSessionId,
+      targetSessionId,
+      getClient,
+    })
+
+    await expect(getSessionModel(targetSessionId)).resolves.toMatchInlineSnapshot(`
+      {
+        "modelId": "anthropic/claude-opus-4-6",
+        "variant": "thinking",
+      }
+    `)
+
+    await db.delete(schema.session_models).where(orm.inArray(schema.session_models.session_id, [sourceSessionId, targetSessionId]))
+  })
+
   test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
     const db = await getDb()
     const threadId = 'test-session-events-thread'

package/src/opencode.ts

@@ -735,6 +735,26 @@ async function startSingleServer({
     experimental: {
       continue_loop_on_deny: true,
     },
+    provider: {
+      xai: {
+        models: {
+          'grok-composer-2.5-fast': {
+            name: 'Grok Composer 2.5 Fast',
+            attachment: true,
+            tool_call: true,
+            limit: {
+              context: 256000,
+              output: 256000,
+            },
+            cost: {
+              input: 0.50,
+              output: 2.50,
+              cache_read: 0.20,
+            },
+          },
+        },
+      },
+    },
     skills: {
       paths: [path.resolve(__dirname, '..', 'skills')],
     },