kimaki 0.26.0 → 0.28.0

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.
  *
@@ -25,7 +26,7 @@
 import { appendToastSessionMarker } from "./plugin-logger.js";
 import { createPluginClient } from "./plugin-opencode-client.js";
 import { isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
-import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
+import { applyClaudeCodeRequestIdentity, extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
 function base64urlEncode(bytes) {
@@ -62,7 +63,6 @@ const CALLBACK_PATH = "/callback";
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
 const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
 const OAUTH_TIMEOUT_MS = 5 * 60 * 1000;
-const CLAUDE_CODE_VERSION = "2.1.75";
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
 // Subagent prompts don't contain OPENCODE_IDENTITY; opencode appends this
@@ -242,13 +242,10 @@ async function fetchAnthropicAccountIdentity(accessToken) {
     for (const url of urls) {
         const responseText = await requestText(url, {
             method: "GET",
-            headers: {
-                Accept: "application/json",
-                authorization: `Bearer ${accessToken}`,
-                "user-agent": process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
-                    `claude-cli/${CLAUDE_CODE_VERSION}`,
-                "x-app": "cli",
-            },
+            headers: Object.fromEntries(applyClaudeCodeRequestIdentity({
+                headers: new Headers({ Accept: "application/json" }),
+                accessToken,
+            }).entries()),
         }).catch(() => {
             return undefined;
         });
@@ -876,10 +873,10 @@ const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
                             requestHeaders.set("accept", "application/json");
                             requestHeaders.set("anthropic-beta", mergeBetas(requestHeaders.get("anthropic-beta"), betas));
                             requestHeaders.set("anthropic-dangerous-direct-browser-access", "true");
-                            requestHeaders.set("authorization", `Bearer ${auth.access}`);
-                            requestHeaders.set("user-agent", process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
-                                `claude-cli/${CLAUDE_CODE_VERSION}`);
-                            requestHeaders.set("x-app", "cli");
+                            applyClaudeCodeRequestIdentity({
+                                headers: requestHeaders,
+                                accessToken: auth.access,
+                            });
                             requestHeaders.delete("x-api-key");
                             return fetch(input, {
                                 ...(init ?? {}),

package/dist/anthropic-auth-plugin.test.js

@@ -1,5 +1,6 @@
 // Tests Anthropic system prompt rewriting so project instructions survive OpenCode prompt layout changes.
 import { describe, expect, test } from 'vitest';
+import { applyClaudeCodeRequestIdentity } from './anthropic-account-identity.js';
 import { replacer } from './anthropic-auth-plugin.js';
 async function transformSystem(systemText) {
     const plugin = await replacer({});
@@ -12,6 +13,22 @@ async function transformSystem(systemText) {
     }, output);
     return output.system.join('\n');
 }
+describe('Anthropic OAuth request identity', () => {
+    test('applies the current external Claude Code client headers', () => {
+        const headers = applyClaudeCodeRequestIdentity({
+            headers: new Headers({ Accept: 'application/json' }),
+            accessToken: 'access-token',
+        });
+        expect(Object.fromEntries(headers.entries())).toMatchInlineSnapshot(`
+      {
+        "accept": "application/json",
+        "authorization": "Bearer access-token",
+        "user-agent": "claude-cli/2.1.257 (external, cli)",
+        "x-app": "cli",
+      }
+    `);
+    });
+});
 describe('Anthropic system prompt rewriting', () => {
     test('preserves instructions when OpenCode places them before skills', async () => {
         const transformed = await transformSystem(`You are OpenCode, the best coding agent on the planet.

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/bash-tool-schema-plugin.js

@@ -0,0 +1,32 @@
+// Adds description and hasSideEffect to the built-in bash tool schema.
+// Uses tool.definition so OpenCode keeps the real bash execute.
+// Assign jsonSchema only. Leave parameters as the Effect Schema used to decode
+// args before execute. Extra fields stay in the model-facing schema and in
+// Discord input; they never reach the shell.
+import { z } from 'zod';
+export const bashParameters = z.object({
+    command: z.string().describe('The command to execute'),
+    description: z
+        .string()
+        .describe('Short 5-10 word summary shown in Discord when the command is longer than 50 characters'),
+    hasSideEffect: z
+        .boolean()
+        .describe('True if the command writes files, modifies state, installs packages, or triggers external effects'),
+    workdir: z
+        .string()
+        .optional()
+        .describe('Working directory. Defaults to the current directory.'),
+    timeout: z.number().int().optional().describe('Optional timeout in milliseconds'),
+});
+export function extendBashToolDefinition(output) {
+    output.jsonSchema = z.toJSONSchema(bashParameters);
+}
+export const bashToolSchemaPlugin = async () => {
+    return {
+        'tool.definition': async (input, output) => {
+            if (input.toolID !== 'bash')
+                return;
+            extendBashToolDefinition(output);
+        },
+    };
+};

package/dist/bash-tool-schema-plugin.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import { extendBashToolDefinition, } from './bash-tool-schema-plugin.js';
+describe('extendBashToolDefinition', () => {
+    test('keeps parameters and assigns jsonSchema from bashParameters', () => {
+        const parameters = { keep: true };
+        const output = {
+            description: 'Execute a shell command',
+            parameters,
+        };
+        extendBashToolDefinition(output);
+        expect(output.parameters).toBe(parameters);
+        expect(output.jsonSchema).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": false,
+        "properties": {
+          "command": {
+            "description": "The command to execute",
+            "type": "string",
+          },
+          "description": {
+            "description": "Short 5-10 word summary shown in Discord when the command is longer than 50 characters",
+            "type": "string",
+          },
+          "hasSideEffect": {
+            "description": "True if the command writes files, modifies state, installs packages, or triggers external effects",
+            "type": "boolean",
+          },
+          "timeout": {
+            "description": "Optional timeout in milliseconds",
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer",
+          },
+          "workdir": {
+            "description": "Working directory. Defaults to the current directory.",
+            "type": "string",
+          },
+        },
+        "required": [
+          "command",
+          "description",
+          "hasSideEffect",
+        ],
+        "type": "object",
+      }
+    `);
+    });
+});

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/project.js

@@ -12,7 +12,7 @@ import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
 import { getDefaultKimakiDirectory } from '../channel-management.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -39,8 +39,15 @@ cli
         cliLogger.error(`Directory does not exist: ${absolutePath}`);
         process.exit(EXIT_NO_RESTART);
     }
-    // Initialize database
     await initDatabase();
+    const existingChannel = await findRegisteredTextChannelForDirectory(absolutePath);
+    if (existingChannel) {
+        cliLogger.error(formatProjectAlreadyRegisteredError({
+            channelId: existingChannel.channel_id,
+            directory: absolutePath,
+        }));
+        process.exit(EXIT_NO_RESTART);
+    }
     const { token: botToken, appId } = await resolveBotCredentials({
         appIdOverride: options.appId,
     });
@@ -62,30 +69,6 @@ cli
     });
     cliLogger.log('Finding guild...');
     const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
-    // Check if channel already exists in this guild
-    cliLogger.log('Checking for existing channel...');
-    try {
-        const existingChannels = await findChannelsByDirectory({
-            directory: absolutePath,
-            channelType: 'text',
-        });
-        for (const existingChannel of existingChannels) {
-            try {
-                const ch = await client.channels.fetch(existingChannel.channel_id);
-                if (ch && !ch.isDMBased() && ch.guild.id === guild.id) {
-                    void client.destroy();
-                    cliLogger.error(`Channel already exists for this directory in ${guild.name}. Channel ID: ${existingChannel.channel_id}`);
-                    process.exit(EXIT_NO_RESTART);
-                }
-            }
-            catch (error) {
-                cliLogger.debug(`Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`, error instanceof Error ? error.stack : String(error));
-            }
-        }
-    }
-    catch (error) {
-        cliLogger.debug('Database lookup failed while checking existing channels:', error instanceof Error ? error.stack : String(error));
-    }
     const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
         guild,
         projectDirectory: absolutePath,
@@ -131,7 +114,8 @@ cli
             }
             catch (error) {
                 // Only mark as deleted for Unknown Channel (10003) or 404,
-                // not transient errors like rate limits or 5xx
+                // not transient errors like rate limits or 5xx.
+                // Gateway-proxy must return Discord 404 for unknown channels, not 403.
                 const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
                 const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
                 const isUnknownChannel = code === 10003 || status === 404;

package/dist/cli-commands/send.js

@@ -21,6 +21,7 @@ import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
 import { WORKTREE_PREFIX } from '../commands/merge-worktree.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, ensureThreadMember, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
@@ -29,6 +30,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 +91,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 +344,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)) {
@@ -378,6 +395,10 @@ cli
             }
             const threadPromptMarker = {
                 start: true,
+                ...(threadTargetUser && {
+                    userId: threadTargetUser.id,
+                    ...(threadTargetUser.username && { username: threadTargetUser.username }),
+                }),
                 ...(options.agent && { agent: options.agent }),
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
@@ -393,7 +414,7 @@ cli
             // Prefix the prompt so it's clear who sent it (matches /queue format).
             // Use a newline between prefix and prompt so leading /command
             // detection can find the command on its own line.
-            const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
+            const prefixedPrompt = `${QUEUE_PREFIX}**kimaki-cli:**\n${prompt}`;
             if (threadTargetUser) {
                 cliLogger.log(`Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`);
                 const addMemberResult = await ensureThreadMember({
@@ -446,6 +467,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) {