kimaki 0.26.0 → 0.27.0

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

@@ -402,7 +402,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -446,7 +446,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ system-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
     }, 15_000);
     test('session.command path includes kimaki system prompt on first message', async () => {
@@ -552,7 +552,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/channel-model-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2* <@200000000000000920>"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -565,40 +565,30 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
-    test('channel model with variant preference completes without error', async () => {
-        // Clear channel agent so model resolution falls through to channel model
+    test('unsupported channel model variant falls back to the selected model', async () => {
         const db = await getDb();
         await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
-        // Set channel model with a variant (thinking level)
-        // The deterministic provider doesn't support thinking, so the variant
-        // is resolved but silently dropped (no matching thinking values).
-        // This test verifies the variant cascade code path runs without crashing
-        // and the correct model still appears in the footer.
         await setChannelModel({
             channelId: TEXT_CHANNEL_ID,
             modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
             variant: 'high',
         });
+        const prompt = 'Reply with exactly: variant-check';
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: variant-check',
+            content: prompt,
         });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: variant-check';
-            },
+            predicate: (candidate) => candidate.name === prompt,
         });
-        await waitForBotMessageContaining({
+        const messages = await waitForFooterMessage({
             discord,
             threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: '*project',
             timeout: 4_000,
         });
-        const messages = await discord.thread(thread.id).getMessages();
-        const footerMessage = messages.find((message) => {
-            return (message.author.id === discord.botUserId &&
-                message.content.startsWith('*'));
+        const footer = messages.find((message) => {
+            return message.author.id === discord.botUserId
+                && message.content.startsWith('*');
         });
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: user (agent-model-tester)
@@ -606,18 +596,10 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/channel-model-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2* <@200000000000000920>"
       `);
-        expect(footerMessage).toBeDefined();
-        if (!footerMessage) {
-            throw new Error(`Expected footer message but none found. Bot messages: ${messages
-                .filter((m) => m.author.id === discord.botUserId)
-                .map((m) => m.content.slice(0, 150))
-                .join(' | ')}`);
-        }
-        // Footer should still contain the channel model (variant doesn't crash)
-        expect(footerMessage.content).toContain(CHANNEL_MODEL);
-        expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
+        expect(footer?.content).toContain(CHANNEL_MODEL);
+        expect(footer?.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
     test('/btw fork keeps source session model when channel model differs', async () => {
         const db = await getDb();
@@ -681,7 +663,7 @@ describe('agent model resolution', () => {
         Reusing context from <#SOURCE_THREAD> to answer prompt...
         Reply with exactly: btw-model-check
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2* <@200000000000000920>"
       `);
         expect(forkedSessionModel).toMatchInlineSnapshot(`
         {
@@ -746,12 +728,12 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         --- from: user (agent-model-tester)
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
         const secondFooter = [...secondMessages]
@@ -765,85 +747,6 @@ describe('agent model resolution', () => {
         expect(secondFooter.content).toContain(AGENT_MODEL);
         expect(secondFooter.content).not.toContain(PLAN_AGENT_MODEL);
     }, 20_000);
-    test('thread created with no agent keeps default model after channel agent is set', async () => {
-        // Clear any channel agent — thread starts with default (no agent)
-        const db = await getDb();
-        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
-        // Also clear channel model so we get the pure default
-        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
-        // 1. Send a message to create a thread (no channel agent set)
-        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: default-thread-msg',
-        });
-        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: default-thread-msg';
-            },
-        });
-        // Wait for footer — should show the default model
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'ok',
-            afterAuthorId: discord.botUserId,
-        });
-        const firstMessages = await discord.thread(thread.id).getMessages();
-        const firstFooter = firstMessages.find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
-        });
-        expect(firstFooter).toBeDefined();
-        // First run uses the default model (no agent set)
-        expect(firstFooter.content).toContain(DEFAULT_MODEL);
-        expect(firstFooter.content).not.toContain(AGENT_MODEL);
-        // 2. Set channel agent to test-agent via /test-agent-agent in the CHANNEL
-        const { id: interactionId } = await discord
-            .channel(TEXT_CHANNEL_ID)
-            .user(TEST_USER_ID)
-            .runSlashCommand({ name: 'test-agent-agent' });
-        await discord
-            .channel(TEXT_CHANNEL_ID)
-            .waitForInteractionAck({ interactionId, timeout: 4_000 });
-        // 3. Send a second message in the EXISTING thread
-        await discord
-            .thread(thread.id)
-            .user(TEST_USER_ID)
-            .sendMessage({
-            content: 'Reply with exactly: default-second-msg',
-        });
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'default-second-msg',
-            afterAuthorId: TEST_USER_ID,
-        });
-        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
-        "--- from: user (agent-model-tester)
-        Reply with exactly: default-thread-msg
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (agent-model-tester)
-        Reply with exactly: default-second-msg
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        const secondMessages = await discord.thread(thread.id).getMessages();
-        const secondFooter = [...secondMessages]
-            .reverse()
-            .find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
-        });
-        expect(secondFooter).toBeDefined();
-        // The existing thread should still use the DEFAULT model,
-        // NOT the test-agent's model (AGENT_MODEL)
-        expect(secondFooter.content).toContain(DEFAULT_MODEL);
-        expect(secondFooter.content).not.toContain(AGENT_MODEL);
-    }, 20_000);
     test('/plan-agent with prompt starts a session with the plan agent', async () => {
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
         const prompt = 'Reply with exactly: inline-plan-agent-msg';
@@ -879,7 +782,7 @@ describe('agent model resolution', () => {
         » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
         *using deterministic-provider/plan-model-v2 ⋅ plan*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
     }, 20_000);
     test('/plan-agent with prompt in an existing thread changes the session agent', async () => {
@@ -924,10 +827,10 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         » **agent-model-tester** (plan): Reply with exactly: inline-existing-plan-msg
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
     }, 20_000);
     test('/plan-agent inside a thread switches the model for that thread', async () => {
@@ -978,7 +881,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
@@ -986,7 +889,7 @@ describe('agent model resolution', () => {
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
             .reverse()
@@ -1035,7 +938,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/plan-model-v2 ⋅ plan*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>
         Using **plan** agent for this session
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1077,7 +980,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1119,7 +1022,7 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/channel-model-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2* <@200000000000000920>
         Switched to **plain** agent for this session
         Model: *deterministic-provider/channel-model-v2* (channel override)
         This model comes from a channel override. Use /model and press Clear override if you want this agent's model.

package/dist/anthropic-account-identity.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 // Helpers for extracting and normalizing Anthropic OAuth account identity.
 const identityHintKeys = new Set(['user', 'profile', 'account', 'viewer']);
 const idKeys = ['user_id', 'userId', 'account_id', 'accountId', 'id', 'sub'];

package/dist/anthropic-auth-plugin.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * Anthropic OAuth authentication plugin for OpenCode.
  *

package/dist/anthropic-auth-state.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * Anthropic OAuth account store and rotation.
  * Uses shared utilities from oauth-rotation-shared.ts for file locking,

package/dist/bin.js

@@ -32,14 +32,57 @@ else {
     console.error('no subcommand detected. kimaki will automatically restart on crash');
     console.error();
     const EXIT_NO_RESTART = 64;
+    // Keep in sync with EXIT_TEMPFAIL in cli-runner.ts. Network-down login
+    // failures use this so a long outage cannot trip the crash-loop detector.
+    const EXIT_TEMPFAIL = 75;
     const MAX_RAPID_RESTARTS = 5;
     const RAPID_RESTART_WINDOW_MS = 60_000;
     const RESTART_DELAY_MS = 2_000;
+    const CHILD_EXIT_DEADLINE_MS = 15_000;
     const restartTimestamps = [];
+    let tempFailAttempts = 0;
     let child = null;
     // Track when we forwarded a termination signal so we don't restart after graceful shutdown
     let shutdownRequested = false;
+    let forceKillTimer = null;
+    let scheduledRestart = null;
+    function clearForceKillTimer() {
+        if (!forceKillTimer)
+            return;
+        clearTimeout(forceKillTimer);
+        forceKillTimer = null;
+    }
+    function clearScheduledRestart() {
+        if (!scheduledRestart)
+            return;
+        clearTimeout(scheduledRestart);
+        scheduledRestart = null;
+    }
+    function killChild(signal) {
+        const target = child;
+        if (!target) {
+            if (shutdownRequested) {
+                clearScheduledRestart();
+                process.exit(0);
+            }
+            return;
+        }
+        const sent = target.kill(signal);
+        if (!sent || forceKillTimer)
+            return;
+        forceKillTimer = setTimeout(() => {
+            forceKillTimer = null;
+            if (child !== target)
+                return;
+            console.error(`[kimaki] Child did not exit within ${CHILD_EXIT_DEADLINE_MS / 1000}s, force-killing it`);
+            target.kill('SIGKILL');
+        }, CHILD_EXIT_DEADLINE_MS);
+        forceKillTimer.unref();
+    }
     function start() {
+        if (shutdownRequested)
+            return;
+        scheduledRestart = null;
         if (!fs.existsSync(HEAP_SNAPSHOT_DIR)) {
             fs.mkdirSync(HEAP_SNAPSHOT_DIR, { recursive: true });
         }
@@ -48,32 +91,42 @@ else {
             `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
         ];
         const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)];
-        child = spawn(process.argv[0], args, {
+        const currentChild = spawn(process.argv[0], args, {
             stdio: 'inherit',
             env: { ...process.env, __KIMAKI_CHILD: '1' },
         });
-        child.on('exit', (code, signal) => {
+        child = currentChild;
+        currentChild.on('exit', (code, signal) => {
+            if (child === currentChild)
+                child = null;
+            clearForceKillTimer();
             if (code === 0 || code === EXIT_NO_RESTART || shutdownRequested) {
                 process.exit(code ?? 0);
                 return;
             }
             const now = Date.now();
-            restartTimestamps.push(now);
-            while (restartTimestamps.length > 0 &&
-                restartTimestamps[0] < now - RAPID_RESTART_WINDOW_MS) {
-                restartTimestamps.shift();
-            }
-            if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
-                console.error(`[kimaki] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`);
-                process.exit(1);
-                return;
+            const isTempFail = code === EXIT_TEMPFAIL;
+            if (!isTempFail) {
+                restartTimestamps.push(now);
+                while (restartTimestamps.length > 0 &&
+                    restartTimestamps[0] < now - RAPID_RESTART_WINDOW_MS) {
+                    restartTimestamps.shift();
+                }
+                if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
+                    console.error(`[kimaki] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`);
+                    process.exit(1);
+                    return;
+                }
             }
             const reason = signal ? `signal ${signal}` : `code ${code}`;
             // Progressive backoff: 2s, 4s, 8s, 16s, capped at 30s.
             // Prevents hammering DNS/gateway during sustained network outages.
-            const delay = Math.min(RESTART_DELAY_MS * 2 ** (restartTimestamps.length - 1), 30_000);
+            const backoffStep = isTempFail
+                ? Math.min(tempFailAttempts++, 4)
+                : restartTimestamps.length - 1;
+            const delay = Math.min(RESTART_DELAY_MS * 2 ** backoffStep, 30_000);
             console.error(`[kimaki] Process exited with ${reason}, restarting in ${(delay / 1000).toFixed(0)}s...`);
-            setTimeout(start, delay);
+            scheduledRestart = setTimeout(start, delay);
         });
     }
     // Forward signals to child so graceful shutdown and heap snapshots work.
@@ -81,13 +134,14 @@ else {
     for (const sig of ['SIGTERM', 'SIGINT']) {
         process.on(sig, () => {
             shutdownRequested = true;
-            child?.kill(sig);
-        });
-    }
-    for (const sig of ['SIGUSR1', 'SIGUSR2']) {
-        process.on(sig, () => {
-            child?.kill(sig);
+            killChild(sig);
         });
     }
+    process.on('SIGUSR1', () => {
+        child?.kill('SIGUSR1');
+    });
+    process.on('SIGUSR2', () => {
+        killChild('SIGUSR2');
+    });
     start();
 }

package/dist/cli-commands/maintenance.js

@@ -60,13 +60,21 @@ cli
     }
 });
 cli
-    .command('worktree merge', 'Merge worktree branch into default branch using worktrunk-style pipeline')
+    .command('merge-worktree', 'Merge the current worktree into a target branch')
     .option('-d, --directory <path>', 'Worktree directory (defaults to cwd)')
     .option('-m, --main-repo <path>', 'Main repository directory (auto-detected from worktree)')
     .option('-n, --name <name>', 'Worktree/branch name (auto-detected from branch)')
+    .option('--strategy [strategy]', z.enum(['rebase', 'squash'])
+    .default('rebase')
+    .describe('Keep commits or squash them into one'))
+    .option('--target-branch [branch]', z.string()
+    .optional()
+    .describe('Branch to merge into (defaults to origin/HEAD or main)'))
+    .option('--thread [threadId]', z.string().optional().describe('Discord thread to mark as merged'))
+    .option('--thread-name [name]', z.string().optional().describe('Discord thread name after merging'))
     .action(async (options) => {
     try {
-        const { mergeWorktree } = await import('../worktrees.js');
+        const { formatMergeWorktreeError, mergeWorktree } = await import('../worktrees.js');
         const worktreeDir = path.resolve(options.directory || '.');
         // Auto-detect main repo: find the main worktree's toplevel.
         // For linked worktrees, --git-common-dir points to the shared .git,
@@ -77,14 +85,20 @@ cli
         if (!mainRepoDir) {
             try {
                 // `git worktree list --porcelain` first line is always the main worktree
-                const { stdout } = await execAsync(`git -C "${worktreeDir}" worktree list --porcelain`);
+                const { stdout } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'worktree', 'list', '--porcelain'],
+                });
                 const firstLine = stdout.split('\n')[0] || '';
                 // Format: "worktree /path/to/main"
                 mainRepoDir = firstLine.replace(/^worktree\s+/, '').trim();
             }
             catch {
                 // Fallback: derive from git common dir
-                const { stdout: commonDir } = await execAsync(`git -C "${worktreeDir}" rev-parse --git-common-dir`);
+                const { stdout: commonDir } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'rev-parse', '--git-common-dir'],
+                });
                 const resolved = path.isAbsolute(commonDir.trim())
                     ? commonDir.trim()
                     : path.resolve(worktreeDir, commonDir.trim());
@@ -95,7 +109,10 @@ cli
         let worktreeName = options.name;
         if (!worktreeName) {
             try {
-                const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+                const { stdout } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'symbolic-ref', '--short', 'HEAD'],
+                });
                 worktreeName = stdout.trim();
             }
             catch {
@@ -110,18 +127,40 @@ cli
             worktreeDir,
             mainRepoDir,
             worktreeName,
+            strategy: options.strategy,
+            targetBranch: options.targetBranch,
             onProgress: (msg) => {
                 cliLogger.log(msg);
             },
         });
         if (result instanceof Error) {
-            cliLogger.error(`Merge failed: ${result.message}`);
+            cliLogger.error(formatMergeWorktreeError(result, { maxLength: 8000 }));
             if (result instanceof RebaseConflictError) {
                 cliLogger.log('Resolve the rebase conflicts, then run this command again.');
             }
             process.exit(1);
         }
-        cliLogger.log(`Merged ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`);
+        const action = options.strategy === 'squash' ? 'Squashed' : 'Merged';
+        cliLogger.log(`${action} ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} source commit${result.commitCount === 1 ? '' : 's'})`);
+        if (options.thread && options.threadName) {
+            const credentials = await resolveBotCredentials().catch((e) => {
+                return new Error('Failed to resolve Discord credentials', { cause: e });
+            });
+            if (credentials instanceof Error) {
+                cliLogger.warn(`Could not update the thread title: ${credentials.message}`);
+            }
+            else {
+                const rest = createDiscordRest(credentials.token);
+                const renameResult = await rest
+                    .patch(Routes.channel(options.thread), {
+                    body: { name: options.threadName },
+                })
+                    .catch((e) => new Error('Discord rejected the thread rename', { cause: e }));
+                if (renameResult instanceof Error) {
+                    cliLogger.warn(`Could not update the thread title: ${renameResult.message}`);
+                }
+            }
+        }
         process.exit(0);
     }
     catch (error) {

package/dist/cli-commands/send.js

@@ -29,6 +29,7 @@ import { execAsync, resolveSessionWorkingDirectory, isGitRepositoryRoot } from '
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { validateCliModelOption } from '../session-handler/model-utils.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -89,6 +90,13 @@ cli
             cliLogger.error('Prompt is required. Use --prompt <prompt>');
             process.exit(EXIT_NO_RESTART);
         }
+        const earlyModelCheck = await validateCliModelOption({
+            model: options.model,
+        });
+        if (earlyModelCheck instanceof Error) {
+            cliLogger.error(earlyModelCheck.message);
+            process.exit(EXIT_NO_RESTART);
+        }
         const filePaths = options.file?.length
             ? options.file.map((f) => path.resolve(f))
             : undefined;
@@ -335,6 +343,14 @@ cli
             // We only require it for features that genuinely need a local directory
             // (scheduled tasks and --wait).
             const channelConfig = await getChannelDirectory(threadData.parent_id);
+            const threadModelCheck = await validateCliModelOption({
+                model: options.model,
+                directory: channelConfig?.directory,
+            });
+            if (threadModelCheck instanceof Error) {
+                cliLogger.error(threadModelCheck.message);
+                process.exit(EXIT_NO_RESTART);
+            }
             // Guard early: fail before sending the message if a feature that
             // needs local project directory mapping is requested.
             if (!channelConfig && (parsedSchedule || options.wait)) {
@@ -446,6 +462,14 @@ cli
         // (--send-at, --wait, --cwd).
         const channelConfig = await getChannelDirectory(channelData.id);
         const projectDirectory = channelConfig?.directory;
+        const channelModelCheck = await validateCliModelOption({
+            model: options.model,
+            directory: projectDirectory,
+        });
+        if (channelModelCheck instanceof Error) {
+            cliLogger.error(channelModelCheck.message);
+            process.exit(EXIT_NO_RESTART);
+        }
         // Features that require a local project directory mapping
         const needsProjectDirectory = Boolean(parsedSchedule || options.wait || options.cwd);
         if (!channelConfig && needsProjectDirectory) {