kimaki 0.26.0 → 0.28.0

package/src/anthropic-account-identity.ts

@@ -1,4 +1,23 @@
-// Helpers for extracting and normalizing Anthropic OAuth account identity.
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
+// Helpers for Anthropic OAuth account and Claude Code client identity.
+
+const CLAUDE_CODE_USER_AGENT = 'claude-cli/2.1.257 (external, cli)'
+
+export function applyClaudeCodeRequestIdentity({
+  headers,
+  accessToken,
+}: {
+  headers: Headers
+  accessToken: string
+}) {
+  headers.set('authorization', `Bearer ${accessToken}`)
+  headers.set(
+    'user-agent',
+    process.env.OPENCODE_ANTHROPIC_USER_AGENT || CLAUDE_CODE_USER_AGENT,
+  )
+  headers.set('x-app', 'cli')
+  return headers
+}
 
 export type AnthropicAccountIdentity = {
   email?: string

package/src/anthropic-auth-plugin.test.ts

@@ -1,6 +1,7 @@
 // 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: string) {
@@ -18,6 +19,24 @@ async function transformSystem(systemText: string) {
   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/src/anthropic-auth-plugin.ts

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * Anthropic OAuth authentication plugin for OpenCode.
  *
@@ -41,6 +42,7 @@ import {
   withAuthStateLock,
 } from "./anthropic-auth-state.js";
 import {
+  applyClaudeCodeRequestIdentity,
   extractAnthropicAccountIdentity,
   type AnthropicAccountIdentity,
 } from "./anthropic-account-identity.js";
@@ -90,7 +92,6 @@ 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.";
 
@@ -344,14 +345,12 @@ async function fetchAnthropicAccountIdentity(accessToken: string) {
   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;
     });
@@ -1087,13 +1086,10 @@ const AnthropicAuthPlugin: Plugin = async ({ serverUrl, directory }) => {
                 "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, {

package/src/anthropic-auth-state.ts

@@ -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/src/bash-tool-schema-plugin.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'vitest'
+import {
+  extendBashToolDefinition,
+  type ToolDefinitionOutput,
+} from './bash-tool-schema-plugin.js'
+
+describe('extendBashToolDefinition', () => {
+  test('keeps parameters and assigns jsonSchema from bashParameters', () => {
+    const parameters = { keep: true }
+    const output: ToolDefinitionOutput = {
+      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/src/bash-tool-schema-plugin.ts

@@ -0,0 +1,46 @@
+// 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 type { Plugin } from '@opencode-ai/plugin'
+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 type ToolDefinitionOutput = {
+  description: string
+  parameters: unknown
+  jsonSchema?: unknown
+}
+
+export function extendBashToolDefinition(output: ToolDefinitionOutput) {
+  output.jsonSchema = z.toJSONSchema(bashParameters)
+}
+
+export const bashToolSchemaPlugin: Plugin = async () => {
+  return {
+    'tool.definition': async (input, output) => {
+      if (input.toolID !== 'bash') return
+      extendBashToolDefinition(output)
+    },
+  }
+}

package/src/bin.ts

@@ -35,16 +35,61 @@ if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
   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: number[] = []
+  let tempFailAttempts = 0
   let child: ReturnType<typeof spawn> | null = null
   // Track when we forwarded a termination signal so we don't restart after graceful shutdown
   let shutdownRequested = false
+  let forceKillTimer: ReturnType<typeof setTimeout> | null = null
+  let scheduledRestart: ReturnType<typeof setTimeout> | null = null
+
+  function clearForceKillTimer() {
+    if (!forceKillTimer) return
+    clearTimeout(forceKillTimer)
+    forceKillTimer = null
+  }
+
+  function clearScheduledRestart() {
+    if (!scheduledRestart) return
+    clearTimeout(scheduledRestart)
+    scheduledRestart = null
+  }
+
+  function killChild(signal: NodeJS.Signals) {
+    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 })
     }
@@ -53,7 +98,7 @@ if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
       `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
     ]
     const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)]
-    child = spawn(
+    const currentChild = spawn(
       process.argv[0]!,
       args,
       {
@@ -61,41 +106,47 @@ if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
         env: { ...process.env, __KIMAKI_CHILD: '1' },
       },
     )
+    child = currentChild
 
-    child.on('exit', (code, signal) => {
+    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()
-      }
+      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
+        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)
     })
   }
 
@@ -104,14 +155,15 @@ if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
   for (const sig of ['SIGTERM', 'SIGINT'] as const) {
     process.on(sig, () => {
       shutdownRequested = true
-      child?.kill(sig)
-    })
-  }
-  for (const sig of ['SIGUSR1', 'SIGUSR2'] as const) {
-    process.on(sig, () => {
-      child?.kill(sig)
+      killChild(sig)
     })
   }
+  process.on('SIGUSR1', () => {
+    child?.kill('SIGUSR1')
+  })
+  process.on('SIGUSR2', () => {
+    killChild('SIGUSR2')
+  })
 
   start()
 }

package/src/cli-commands/maintenance.ts

@@ -87,8 +87,8 @@ cli
 
 cli
   .command(
-    'worktree merge',
-    'Merge worktree branch into default branch using worktrunk-style pipeline',
+    'merge-worktree',
+    'Merge the current worktree into a target branch',
   )
   .option('-d, --directory <path>', 'Worktree directory (defaults to cwd)')
   .option(
@@ -99,14 +99,30 @@ cli
     '-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: {
-      directory?: string
-      mainRepo?: string
-      name?: string
-    }) => {
+    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.
@@ -119,7 +135,10 @@ cli
           try {
             // `git worktree list --porcelain` first line is always the main worktree
             const { stdout } = await execAsync(
-              `git -C "${worktreeDir}" worktree list --porcelain`,
+              {
+                command: 'git',
+                args: ['-C', worktreeDir, 'worktree', 'list', '--porcelain'],
+              },
             )
             const firstLine = stdout.split('\n')[0] || ''
             // Format: "worktree /path/to/main"
@@ -127,7 +146,10 @@ cli
           } catch {
             // Fallback: derive from git common dir
             const { stdout: commonDir } = await execAsync(
-              `git -C "${worktreeDir}" rev-parse --git-common-dir`,
+              {
+                command: 'git',
+                args: ['-C', worktreeDir, 'rev-parse', '--git-common-dir'],
+              },
             )
             const resolved = path.isAbsolute(commonDir.trim())
               ? commonDir.trim()
@@ -141,7 +163,10 @@ cli
         if (!worktreeName) {
           try {
             const { stdout } = await execAsync(
-              `git -C "${worktreeDir}" symbolic-ref --short HEAD`,
+              {
+                command: 'git',
+                args: ['-C', worktreeDir, 'symbolic-ref', '--short', 'HEAD'],
+              },
             )
             worktreeName = stdout.trim()
           } catch {
@@ -159,13 +184,15 @@ 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.',
@@ -174,9 +201,28 @@ cli
           process.exit(1)
         }
 
+        const action = options.strategy === 'squash' ? 'Squashed' : 'Merged'
         cliLogger.log(
-          `Merged ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`,
+          `${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) {
         cliLogger.error(

package/src/cli-commands/project.ts

@@ -13,7 +13,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'
@@ -77,9 +77,19 @@ cli
         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,
       })
@@ -109,38 +119,6 @@ cli
 
       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,
@@ -207,7 +185,8 @@ cli
             guildId = data.guild_id || ''
           } 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/src/cli-commands/send.ts

@@ -26,6 +26,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 type { ThreadStartMarker } from '../system-message.js'
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js'
 import { createDiscordRest } from '../discord-urls.js'
@@ -47,6 +48,7 @@ import {
   resolveDiscordUserOption,
   sendDiscordMessageWithOptionalAttachment,
 } from '../cli-runner.js'
+import { validateCliModelOption } from '../session-handler/model-utils.js'
 
 const cliLogger = createLogger(LogPrefix.CLI)
 const cli = goke()
@@ -178,6 +180,14 @@ cli
           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: string) => path.resolve(f))
           : undefined
@@ -485,6 +495,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.
@@ -537,6 +555,10 @@ cli
 
           const threadPromptMarker: ThreadStartMarker = {
             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 } : {}),
@@ -553,7 +575,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(
@@ -624,6 +646,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)