kimaki 0.15.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/cli-commands/send.js

@@ -457,6 +457,7 @@ cli
             botToken,
             embeds: autoStartEmbed,
             rest,
+            splitInsteadOfAttach: notifyOnly,
         });
         // For notify-only on non-project channels, just post the message without
         // creating a thread. There's no session to start, so a thread is unnecessary.

package/dist/cli-runner.js

@@ -107,7 +107,7 @@ export function isThreadChannelType(type) {
         ChannelType.AnnouncementThread,
     ].includes(type);
 }
-export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, }) {
+export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, }) {
     const discordMaxLength = 2000;
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
@@ -118,6 +118,33 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             },
         }));
     }
+    if (splitInsteadOfAttach) {
+        const { splitMarkdownForDiscord } = await import('./discord-utils.js');
+        const chunks = splitMarkdownForDiscord({
+            content: prompt,
+            maxLength: discordMaxLength,
+        });
+        let firstMessage;
+        for (let chunk of chunks) {
+            if (!chunk?.trim())
+                continue;
+            // Safety net: hard-truncate if splitting still produced an oversized chunk
+            if (chunk.length > discordMaxLength) {
+                chunk = chunk.slice(0, discordMaxLength - 4) + '...';
+            }
+            const message = (await rest.post(Routes.channelMessages(channelId), {
+                body: {
+                    content: chunk,
+                    // Only attach embeds to the first message
+                    ...(firstMessage ? {} : { embeds }),
+                    allowed_mentions: { parse: store.getState().allowedMentions },
+                },
+            }));
+            if (!firstMessage)
+                firstMessage = message;
+        }
+        return firstMessage;
+    }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
     const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
     const tmpDir = path.join(process.cwd(), 'tmp');
@@ -759,8 +786,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
                 options: [
                     {
                         value: 'gateway',
-                        disabled: true,
-                        label: 'Gateway (pre-built Kimaki bot, currently disabled because of Discord verification process. will be re-enabled soon)',
+                        label: 'Gateway (pre-built Kimaki bot, no setup needed)',
                     },
                     {
                         value: 'self_hosted',

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/dist/system-message.js

@@ -535,7 +535,7 @@ When you are approaching the **context window limit** or the user explicitly ask
 kimaki send --channel ${channelId} --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent>${userArg}
 \`\`\`
 
-The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+The command automatically handles long prompts (over 2000 chars) by sending them as file attachments. With \`--notify-only\`, long prompts are split into multiple messages instead so the content is directly visible.
 
 Use this for handoff when:
 - User asks to "handoff", "continue in new thread", or "start fresh session"

package/dist/system-message.test.js

@@ -296,7 +296,7 @@ describe('system-message', () => {
       kimaki send --channel chan_123 --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent> --user '<discord-user-id>'
       \`\`\`
 
-      The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+      The command automatically handles long prompts (over 2000 chars) by sending them as file attachments. With \`--notify-only\`, long prompts are split into multiple messages instead so the content is directly visible.
 
       Use this for handoff when:
       - User asks to "handoff", "continue in new thread", or "start fresh session"

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -25,8 +25,8 @@
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.0",
-    "opencode-deterministic-provider": "^0.0.1",
     "opencode-cached-provider": "^0.0.1",
+    "opencode-deterministic-provider": "^0.0.1",
     "db": "^0.0.0"
   },
   "dependencies": {
@@ -62,10 +62,10 @@
     "yaml": "^2.8.3",
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
-    "traforo": "^0.7.0",
     "errore": "^0.14.1",
     "libsqlproxy": "^0.1.0",
-    "opencode-injection-guard": "^0.2.1"
+    "opencode-injection-guard": "^0.2.1",
+    "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/cli-commands/send.ts

@@ -621,6 +621,7 @@ cli
           botToken,
           embeds: autoStartEmbed,
           rest,
+          splitInsteadOfAttach: notifyOnly,
         })
 
         // For notify-only on non-project channels, just post the message without

package/src/cli-runner.ts

@@ -172,12 +172,17 @@ export async function sendDiscordMessageWithOptionalAttachment({
   botToken,
   embeds,
   rest,
+  splitInsteadOfAttach,
 }: {
   channelId: string
   prompt: string
   botToken: string
   embeds?: Array<{ color: number; footer: { text: string } }>
   rest: REST
+  /** When true, long messages are split into multiple Discord messages instead of
+   *  being attached as a file. Useful for notify-only messages where the content
+   *  should be directly visible in the channel. */
+  splitInsteadOfAttach?: boolean
 }): Promise<{ id: string }> {
   const discordMaxLength = 2000
   if (prompt.length <= discordMaxLength) {
@@ -190,6 +195,32 @@ export async function sendDiscordMessageWithOptionalAttachment({
     })) as { id: string }
   }
 
+  if (splitInsteadOfAttach) {
+    const { splitMarkdownForDiscord } = await import('./discord-utils.js')
+    const chunks = splitMarkdownForDiscord({
+      content: prompt,
+      maxLength: discordMaxLength,
+    })
+    let firstMessage: { id: string } | undefined
+    for (let chunk of chunks) {
+      if (!chunk?.trim()) continue
+      // Safety net: hard-truncate if splitting still produced an oversized chunk
+      if (chunk.length > discordMaxLength) {
+        chunk = chunk.slice(0, discordMaxLength - 4) + '...'
+      }
+      const message = (await rest.post(Routes.channelMessages(channelId), {
+        body: {
+          content: chunk,
+          // Only attach embeds to the first message
+          ...(firstMessage ? {} : { embeds }),
+          allowed_mentions: { parse: store.getState().allowedMentions },
+        },
+      })) as { id: string }
+      if (!firstMessage) firstMessage = message
+    }
+    return firstMessage!
+  }
+
   const preview = prompt.slice(0, 100).replace(/\n/g, ' ')
   const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`
 
@@ -1109,8 +1140,7 @@ export async function resolveCredentials({
           options: [
             {
               value: 'gateway' as const,
-              disabled: true,
-              label: 'Gateway (pre-built Kimaki bot, currently disabled because of Discord verification process. will be re-enabled soon)',
+              label: 'Gateway (pre-built Kimaki bot, no setup needed)',
             },
             {
               value: 'self_hosted' as const,

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')],
     },

package/src/system-message.test.ts

@@ -306,7 +306,7 @@ describe('system-message', () => {
       kimaki send --channel chan_123 --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent> --user '<discord-user-id>'
       \`\`\`
 
-      The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+      The command automatically handles long prompts (over 2000 chars) by sending them as file attachments. With \`--notify-only\`, long prompts are split into multiple messages instead so the content is directly visible.
 
       Use this for handoff when:
       - User asks to "handoff", "continue in new thread", or "start fresh session"

package/src/system-message.ts

@@ -649,7 +649,7 @@ When you are approaching the **context window limit** or the user explicitly ask
 kimaki send --channel ${channelId} --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent>${userArg}
 \`\`\`
 
-The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+The command automatically handles long prompts (over 2000 chars) by sending them as file attachments. With \`--notify-only\`, long prompts are split into multiple messages instead so the content is directly visible.
 
 Use this for handoff when:
 - User asks to "handoff", "continue in new thread", or "start fresh session"