kimaki 0.26.0 → 0.28.0

package/src/cli-commands/task.ts

@@ -24,7 +24,7 @@ import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-u
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js'
 import { execAsync, validateWorktreeDirectory } from '../worktrees.js'
 import { upgrade, getCurrentVersion } from '../upgrade.js'
-import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, type ScheduledTaskPayload } from '../task-schedule.js'
+import { applyScheduledTaskUserEdit, getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, type ScheduledTaskPayload } from '../task-schedule.js'
 import {
   EXIT_NO_RESTART,
   formatMemberLookupUnavailableMessage,
@@ -39,6 +39,7 @@ import {
   resolveDiscordUserOption,
   sendDiscordMessageWithOptionalAttachment,
 } from '../cli-runner.js'
+import { validateCliModelOption } from '../session-handler/model-utils.js'
 
 const cliLogger = createLogger(LogPrefix.CLI)
 const cli = goke()
@@ -192,7 +193,7 @@ cli
   )
   .option(
     '-u, --user <user>',
-    'Discord user ID, mention, or username added to the task thread',
+    'Discord user ID, mention, or username added to the task thread (empty string clears)',
   )
   .action(async (id, options) => {
     try {
@@ -202,11 +203,12 @@ cli
       const hasModel = options.model !== undefined
       const hasPreRun = options.preRun !== undefined
       const hasAllowConcurrency = options.allowConcurrency !== undefined
+      const hasUser = options.user !== undefined
 
       if (
         !trimmedPrompt &&
         !options.sendAt &&
-        !options.user &&
+        !hasUser &&
         !hasAgent &&
         !hasModel &&
         !hasPreRun &&
@@ -251,7 +253,7 @@ cli
         process.exit(EXIT_NO_RESTART)
       }
 
-      const resolvedUser = options.user
+      const resolvedUser = hasUser && options.user.trim()
         ? await resolveTaskUser({
             user: options.user,
             channelId: task.channel_id,
@@ -263,24 +265,39 @@ cli
       }
 
       const newPrompt = trimmedPrompt ?? existingPayload.prompt
+      const nextModel = hasModel ? options.model!.trim() || null : existingPayload.model
+      if (nextModel) {
+        const modelCheck = await validateCliModelOption({
+          model: nextModel,
+          directory: task.project_directory ?? undefined,
+        })
+        if (modelCheck instanceof Error) {
+          cliLogger.error(modelCheck.message)
+          process.exit(EXIT_NO_RESTART)
+        }
+      }
       // Match send --model/--agent: empty string clears the override (null).
       const updatedPayload: ScheduledTaskPayload = {
         ...existingPayload,
         prompt: newPrompt,
-        ...(resolvedUser
-          ? { userId: resolvedUser.id, username: resolvedUser.username || null }
-          : {}),
         ...(hasAgent ? { agent: options.agent!.trim() || null } : {}),
-        ...(hasModel ? { model: options.model!.trim() || null } : {}),
+        ...(hasModel ? { model: nextModel } : {}),
         ...(hasPreRun ? { preRunCommand: options.preRun!.trim() || null } : {}),
         ...(hasAllowConcurrency
           ? { allowConcurrency: options.allowConcurrency === 'true' }
           : {}),
       }
+      const payloadWithUser = hasUser
+        ? applyScheduledTaskUserEdit({
+            payload: updatedPayload,
+            userOption: options.user,
+            resolvedUser,
+          })
+        : updatedPayload
 
       const updateData: Parameters<typeof updateScheduledTask>[0] = {
         taskId,
-        payloadJson: serializeScheduledTaskPayload(updatedPayload),
+        payloadJson: serializeScheduledTaskPayload(payloadWithUser),
         promptPreview: getPromptPreview(newPrompt),
       }
 
@@ -309,20 +326,22 @@ cli
       }
 
       const parts: string[] = [`Updated task ${taskId}`]
-      if (resolvedUser) {
+      if (hasUser) {
         parts.push(
-          `user ${resolvedUser.username || resolvedUser.id} will be added to the thread`,
+          payloadWithUser.userId
+            ? `user ${payloadWithUser.username || payloadWithUser.userId} will be added to the thread`
+            : 'user cleared; nobody will be added to the thread',
         )
       }
       if (hasAgent) {
-        parts.push(`agent=${updatedPayload.agent || '-'}`)
+        parts.push(`agent=${payloadWithUser.agent || '-'}`)
       }
       if (hasModel) {
-        parts.push(`model=${updatedPayload.model || '-'}`)
+        parts.push(`model=${payloadWithUser.model || '-'}`)
       }
-      if (hasPreRun) parts.push(`preRun=${updatedPayload.preRunCommand || '-'}`)
+      if (hasPreRun) parts.push(`preRun=${payloadWithUser.preRunCommand || '-'}`)
       if (hasAllowConcurrency) {
-        parts.push(`allowConcurrency=${updatedPayload.allowConcurrency}`)
+        parts.push(`allowConcurrency=${payloadWithUser.allowConcurrency}`)
       }
       cliLogger.log(parts.join(' | '))
       process.exit(0)

package/src/cli-parsing.test.ts

@@ -1,6 +1,7 @@
 // Regression tests for CLI argument parsing around Discord ID string preservation.
 import { describe, expect, test } from 'vitest'
 import { execAsync } from './exec-async.js'
+import maintenanceCommands from './cli-commands/maintenance.js'
 
 async function parseWithGoke(argv: string[]) {
   const script = [
@@ -8,10 +9,12 @@ async function parseWithGoke(argv: string[]) {
     'const cli = goke(\'kimaki\')',
     "cli.command('send', 'Send a message').option('-c, --channel <channelId>', 'Discord channel ID').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--send-at <schedule>', 'Schedule')",
     "cli.command('session archive <threadId>', 'Archive a thread')",
-    "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path')",
+    "cli.command('session title <title>', 'Update title').option('--session <sessionId>', 'Session ID').option('--thread <threadId>', 'Thread ID')",
+    "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path').option('--all', 'Search all registered projects').option('--days <n>', 'Only search recent sessions')",
     "cli.command('session export-events-jsonl', 'Export in-memory events to JSONL').option('--session <sessionId>', 'Session ID').option('--out <file>', 'Output path')",
     "cli.command('add-project', 'Add a project').option('-g, --guild <guildId>', 'Discord guild/server ID')",
     "cli.command('task delete <id>', 'Delete task')",
+    "cli.command('task edit <id>', 'Edit task').option('-u, --user <user>', 'Discord user')",
     "cli.command('multioauth anthropic list', 'List stored Anthropic accounts')",
     "cli.command('multioauth anthropic remove <indexOrEmail>', 'Remove stored Anthropic account')",
     "cli.command('multioauth openai list', 'List stored OpenAI accounts')",
@@ -55,7 +58,7 @@ async function parseRootBotOptions(argv: string[]) {
   const script = [
     "import { goke } from 'goke'",
     'const cli = goke(\'kimaki\')',
-    "cli.command('', 'bot').option('--no-analytics', 'Disable analytics')",
+    "cli.command('', 'bot').option('--no-analytics', 'Disable analytics').option('--skip-footer-mentions', 'Do not mention the thread creator in final footers')",
     `const result = await cli.parse(${JSON.stringify(argv)}, { run: false })`,
     'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
   ].join(';')
@@ -106,6 +109,28 @@ describe('goke CLI ID parsing', () => {
     expect(typeof result.options.guild).toBe('string')
   })
 
+  test('keeps session title and session ID as strings', async () => {
+    const sessionId = '001111222233334444'
+    const title = 'Fix queue draining'
+
+    const result = await parseWithGoke(
+      [
+        'node',
+        'kimaki',
+        'session',
+        'title',
+        title,
+        '--session',
+        sessionId,
+      ],
+    )
+
+    expect(result.args[0]).toBe(title)
+    expect(typeof result.args[0]).toBe('string')
+    expect(result.options.session).toBe(sessionId)
+    expect(typeof result.options.session).toBe('string')
+  })
+
   test('keeps session archive thread ID as string', async () => {
     const threadId = '0098765432109876543'
 
@@ -131,6 +156,23 @@ describe('goke CLI ID parsing', () => {
     expect(typeof result.options.channel).toBe('string')
   })
 
+  test('parses session search --all as a boolean', async () => {
+    const result = await parseWithGoke(
+      ['node', 'kimaki', 'session', 'search', 'auth timeout', '--all'],
+    )
+
+    expect(result.args[0]).toBe('auth timeout')
+    expect(result.options.all).toBe(true)
+  })
+
+  test('parses session search --days as a string', async () => {
+    const result = await parseWithGoke(
+      ['node', 'kimaki', 'session', 'search', 'auth timeout', '--days', '0'],
+    )
+
+    expect(result.options.days).toBe('0')
+  })
+
   test('keeps session export options as strings', async () => {
     const sessionId = '001111222233334444'
     const outPath = './tmp/session-events.jsonl'
@@ -172,6 +214,21 @@ describe('goke CLI ID parsing', () => {
     expect(typeof result.args[0]).toBe('string')
   })
 
+  test('parses empty --user on task edit so the stored user can be cleared', async () => {
+    const result = await parseWithGoke([
+      'node',
+      'kimaki',
+      'task',
+      'edit',
+      '11',
+      '--user',
+      '',
+    ])
+
+    expect(result.args[0]).toBe('11')
+    expect(result.options.user).toBe('')
+  })
+
   test('multioauth account remove parses index and email as strings', async () => {
     const indexResult = await parseWithGoke(
       ['node', 'kimaki', 'multioauth', 'anthropic', 'remove', '2'],
@@ -194,13 +251,55 @@ describe('goke CLI ID parsing', () => {
     expect(stdout).toContain('multioauth')
   })
 
-  test('parses --no-analytics as a boolean flag on the root bot command', async () => {
+  test('merge-worktree parses strategy and target branch', async () => {
+    const result = await maintenanceCommands.parse(
+      [
+        'node',
+        'kimaki',
+        'merge-worktree',
+        '--strategy',
+        'squash',
+        '--target-branch',
+        'release',
+        '--thread',
+        '123456789012345678',
+        '--thread-name',
+        'feature work',
+      ],
+      { run: false },
+    )
+
+    expect({
+      command: maintenanceCommands.matchedCommandName,
+      strategy: result.options.strategy,
+      targetBranch: result.options.targetBranch,
+      thread: result.options.thread,
+      threadName: result.options.threadName,
+    }).toMatchInlineSnapshot(`
+      {
+        "command": "merge-worktree",
+        "strategy": "squash",
+        "targetBranch": "release",
+        "thread": "123456789012345678",
+        "threadName": "feature work",
+      }
+    `)
+  })
+
+  test('parses root bot boolean flags', async () => {
     const result = await parseRootBotOptions([
       'node',
       'kimaki',
       '--no-analytics',
+      '--skip-footer-mentions',
     ])
 
-    expect(result.options.noAnalytics).toBe(true)
+    expect(result.options).toMatchInlineSnapshot(`
+      {
+        "--": [],
+        "noAnalytics": true,
+        "skipFooterMentions": true,
+      }
+    `)
   })
 })

package/src/cli-runner.test.ts

@@ -77,4 +77,53 @@ describe('isTransientNetworkError', () => {
     })
     expect(isTransientNetworkError(error)).toBe(true)
   })
+
+  test('treats undici connect timeouts as transient', () => {
+    const error = Object.assign(
+      new Error(
+        'Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)',
+      ),
+      {
+        name: 'ConnectTimeoutError',
+        code: 'UND_ERR_CONNECT_TIMEOUT',
+      },
+    )
+    expect(isTransientNetworkError(error)).toBe(true)
+  })
+
+  test('matches undici connect timeouts by message when code is missing', () => {
+    expect(
+      isTransientNetworkError(
+        new Error(
+          'Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)',
+        ),
+      ),
+    ).toBe(true)
+  })
+
+  test('walks cause chains for nested undici connect timeouts', () => {
+    const cause = Object.assign(
+      new Error(
+        'Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)',
+      ),
+      {
+        name: 'ConnectTimeoutError',
+        code: 'UND_ERR_CONNECT_TIMEOUT',
+      },
+    )
+    expect(
+      isTransientNetworkError(new Error('Failed to connect to Discord', { cause })),
+    ).toBe(true)
+  })
+
+  test('treats other undici timeout and socket codes as transient', () => {
+    for (const [name, code] of [
+      ['HeadersTimeoutError', 'UND_ERR_HEADERS_TIMEOUT'],
+      ['BodyTimeoutError', 'UND_ERR_BODY_TIMEOUT'],
+      ['SocketError', 'UND_ERR_SOCKET'],
+    ] as const) {
+      const error = Object.assign(new Error(name), { name, code })
+      expect(isTransientNetworkError(error)).toBe(true)
+    }
+  })
 })

package/src/cli-runner.ts

@@ -29,6 +29,7 @@ import {
   getChannelDirectory,
   startDiscordBot,
   initializeOpencodeForDirectory,
+  assertCompatibleOpencodeVersion,
   createProjectChannels,
   createDefaultKimakiChannel,
   type ChannelWithTags,
@@ -456,6 +457,10 @@ export function formatTaskScheduleLine(schedule: ParsedSendAt): string {
 }
 
 export const EXIT_NO_RESTART = 64
+// Temporary failure (sysexits EX_TEMPFAIL). Wrapper retries forever with
+// backoff and does not count this toward the crash-loop detector. Used when
+// Discord login fails because the network is down.
+export const EXIT_TEMPFAIL = 75
 
 export type GuildMemberSearchResult = {
   user: { id: string; username: string; global_name?: string }
@@ -542,6 +547,20 @@ const TRANSIENT_ERROR_CODES = new Set([
   'DEPTH_ZERO_SELF_SIGNED_CERT',
   'SELF_SIGNED_CERT_IN_CHAIN',
   'ERR_TLS_CERT_ALTNAME_INVALID',
+  // undici fetch/WebSocket connect failures when the network is down.
+  // Without these, Discord login exits EXIT_NO_RESTART and the wrapper never
+  // comes back after a connect timeout to discord-gateway.kimaki.dev.
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_HEADERS_TIMEOUT',
+  'UND_ERR_BODY_TIMEOUT',
+  'UND_ERR_SOCKET',
+])
+
+const TRANSIENT_ERROR_NAMES = new Set([
+  'ConnectTimeoutError',
+  'HeadersTimeoutError',
+  'BodyTimeoutError',
+  'SocketError',
 ])
 
 const TRANSIENT_ERROR_MESSAGE_PATTERNS = [
@@ -549,12 +568,16 @@ const TRANSIENT_ERROR_MESSAGE_PATTERNS = [
   /certificate has expired/i,
   /self[- ]signed certificate/i,
   /unable to get local issuer certificate/i,
+  /connect timeout error/i,
+  /headers timeout error/i,
+  /body timeout error/i,
 ]
 
 export function isTransientNetworkError(error: unknown): boolean {
   if (!(error instanceof Error)) return false
   const code = (error as NodeJS.ErrnoException).code
   if (code && TRANSIENT_ERROR_CODES.has(code)) return true
+  if (TRANSIENT_ERROR_NAMES.has(error.name)) return true
   // Fallback when code is stripped by wrappers (discord.js sometimes rethrows by message only).
   if (
     TRANSIENT_ERROR_MESSAGE_PATTERNS.some((pattern) =>
@@ -1082,7 +1105,7 @@ export function showReadyMessage({
 }
 
 /**
- * Create the default kimaki channel in each guild and send a welcome message.
+ * Create default channels in locally configured guilds, or proxy-authorized gateway guilds.
  * Idempotent: skips guilds that already have the channel.
  * Extracted so both the interactive and headless startup paths share the same logic.
  */
@@ -1101,9 +1124,15 @@ export async function ensureDefaultChannelsWithWelcome({
 }): Promise<{ name: string; id: string; guildId: string }[]> {
   if (process.env['KIMAKI_NO_DEFAULT_CHANNEL'] === '1') return []
 
+  const localMappings = isGatewayMode ? [] : await findChannelsByDirectory({})
   const created: { name: string; id: string; guildId: string }[] = []
   for (const guild of guilds) {
     try {
+      if (!isGatewayMode) {
+        // Match live channel IDs: older local mappings have no guild_id.
+        const channels = await guild.channels.fetch()
+        if (!localMappings.some((row) => channels.has(row.channel_id))) continue
+      }
       const result = await createDefaultKimakiChannel({
         guild,
         botName: discordClient.user?.username,
@@ -1586,6 +1615,12 @@ export async function run({
     }),
   ])
 
+  const opencodeVersionCheck = await assertCompatibleOpencodeVersion()
+  if (opencodeVersionCheck instanceof Error) {
+    cliLogger.error(opencodeVersionCheck.message)
+    process.exit(EXIT_NO_RESTART)
+  }
+
 
   if (store.getState().autoUpgradeEnabled) {
     void backgroundUpgradeKimaki()
@@ -1757,12 +1792,14 @@ export async function run({
     cliLogger.error(
       'Error: ' + (error instanceof Error ? error.stack : String(error)),
     )
-    // Transient network errors (DNS down, gateway unreachable) should allow
-    // the bin.ts wrapper to restart us after a delay. Only truly fatal errors
-    // (bad token, invalid intent, etc.) should use EXIT_NO_RESTART.
+    // Transient network errors (DNS down, gateway unreachable, connect
+    // timeout) should allow the bin.ts wrapper to restart us after a delay.
+    // EXIT_TEMPFAIL skips the crash-loop detector so a long outage cannot
+    // permanently stop the bot. Only truly fatal errors (bad token, invalid
+    // intent, etc.) should use EXIT_NO_RESTART.
     if (isTransientNetworkError(error)) {
       cliLogger.error('Transient network error, exiting for wrapper restart...')
-      process.exit(1)
+      process.exit(EXIT_TEMPFAIL)
     }
     process.exit(EXIT_NO_RESTART)
   }
@@ -1823,7 +1860,7 @@ export async function run({
         )
       }
 
-      // Create default kimaki channel + welcome message in each guild.
+      // Create default channels only in locally configured or gateway-authorized guilds.
       // Runs after channel sync so existing channels are detected correctly.
       try {
         await ensureDefaultChannelsWithWelcome({
@@ -2030,7 +2067,7 @@ export async function run({
     }
 
     // Create default kimaki channel for general-purpose tasks.
-    // Runs for every guild the bot is in, idempotent (skips if already exists).
+    // Only locally configured or gateway-authorized guilds are eligible.
     const defaultChannelResults = await ensureDefaultChannelsWithWelcome({
       guilds,
       discordClient,

package/src/cli-send-thread.e2e.test.ts

@@ -410,9 +410,9 @@ describe('kimaki send --channel thread creation', () => {
         "--- from: user (cli-send-tester)
         thread empty content seed
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ caught-by-model
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > caught-by-model
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000830>
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)
         I can see you sent a message, but Discord did not include its text.
@@ -570,13 +570,13 @@ describe('kimaki send --channel thread creation', () => {
         Routes.threadMembers(threadData.id, TEST_USER_ID),
       )
 
-      // Wait for the bot to reply with the ⬥ prefix (proves ThreadCreate
-      // handler picked up the starter message and started a session)
+      // Wait for the bot to reply (proves ThreadCreate handler picked up
+      // the starter message and started a session)
       await waitForBotMessageContaining({
         discord,
         threadId: threadData.id,
         userId: discord.botUserId,
-        text: '⬥',
+        text: 'ok',
         timeout: 4_000,
       })
 
@@ -585,7 +585,7 @@ describe('kimaki send --channel thread creation', () => {
         discord,
         threadId: threadData.id,
         timeout: 4_000,
-        afterMessageIncludes: '⬥',
+        afterMessageIncludes: 'ok',
         afterAuthorId: discord.botUserId,
       })
 
@@ -598,11 +598,9 @@ describe('kimaki send --channel thread creation', () => {
       })
       expect(errorMessages).toHaveLength(0)
 
-      // Verify at least one ⬥ reply exists (session produced output)
+      // Verify at least one reply exists (session produced output)
       const botReplies = messages.filter((m) => {
-        return (
-          m.author.id === discord.botUserId && m.content.startsWith('⬥')
-        )
+        return m.author.id === discord.botUserId
       })
       expect(botReplies.length).toBeGreaterThanOrEqual(1)
     },

package/src/cli.ts

@@ -16,6 +16,7 @@ import {
 } from './config.js'
 import { getCurrentVersion } from './upgrade.js'
 import { store } from './store.js'
+import { publicOpencodeBindRequiresPassword } from './opencode.js'
 import multioauthCommands from './commands/multioauth.js'
 import botCommands from './cli-commands/bot.js'
 import maintenanceCommands from './cli-commands/maintenance.js'
@@ -73,6 +74,10 @@ cli
     '--no-critique',
     'Disable automatic diff upload to critique.work in system prompts',
   )
+  .option(
+    '--skip-footer-mentions',
+    'Do not mention the thread creator in final session footers',
+  )
   .option(
     '--auto-restart',
     'Automatically restart the bot on crash or OOM kill',
@@ -98,6 +103,14 @@ cli
     'Disable anonymous product analytics (Strada). Same as KIMAKI_STRADA_ENABLED=0',
   )
   .option('--no-auto-upgrade', 'Disable background auto-upgrade on startup')
+  .option(
+    '--opencode-hostname <host>',
+    'Hostname the OpenCode server listens on (default: 127.0.0.1). Use 0.0.0.0 to expose it on a VPS',
+  )
+  .option(
+    '--opencode-port <port>',
+    'Port the OpenCode server listens on (default: a random free port)',
+  )
   .option(
     '--gateway',
     'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)',
@@ -145,6 +158,7 @@ cli
       verbosity?: string
       mentionMode?: boolean
       noCritique?: boolean
+      skipFooterMentions?: boolean
       allowAllUsers?: boolean
       restrictDirectories?: boolean
       permissionTimeoutMinutes?: string
@@ -157,6 +171,8 @@ cli
       allowMention?: Array<'users' | 'roles' | 'everyone'>
       enableSkill?: string[]
       disableSkill?: string[]
+      opencodeHostname?: string
+      opencodePort?: string
     }) => {
       // Guard: only one kimaki bot process can run per lock port. Agents may run
       // a second dev bot only when they explicitly choose a different lock port.
@@ -269,12 +285,36 @@ cli
           return parsed * 60_000
         })()
 
+        const opencodeHostname = options.opencodeHostname?.trim() || undefined
+        const opencodePort = (() => {
+          if (!options.opencodePort) return undefined
+          const parsed = Number(options.opencodePort)
+          if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+            cliLogger.error(
+              `Invalid --opencode-port: ${options.opencodePort}. Must be an integer between 1 and 65535.`,
+            )
+            process.exit(EXIT_NO_RESTART)
+          }
+          return parsed
+        })()
+
+        if (
+          publicOpencodeBindRequiresPassword({ hostname: opencodeHostname }) &&
+          !process.env.OPENCODE_SERVER_PASSWORD
+        ) {
+          cliLogger.error(
+            `OPENCODE_SERVER_PASSWORD is required when --opencode-hostname is ${opencodeHostname}. Binding the OpenCode server on a public address without a password lets anyone control the agent.`,
+          )
+          process.exit(EXIT_NO_RESTART)
+        }
+
         store.setState({
           ...(defaultVerbosity && {
             defaultVerbosity,
           }),
           ...(options.mentionMode && { defaultMentionMode: true }),
           ...(options.noCritique && { critiqueEnabled: false }),
+          ...(options.skipFooterMentions && { footerMentionsEnabled: false }),
           ...(options.allowAllUsers && { allowAllUsers: true }),
           ...(options.restrictDirectories && { restrictExternalDirectories: true }),
           ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
@@ -283,6 +323,8 @@ cli
           ...(enabledSkills.length > 0 && { enabledSkills }),
           ...(disabledSkills.length > 0 && { disabledSkills }),
           ...(options.allowMention && { allowedMentions: options.allowMention }),
+          ...(opencodeHostname && { opencodeHostname }),
+          ...(opencodePort !== undefined && { opencodePort }),
         })
 
         if (enabledSkills.length > 0) {
@@ -323,6 +365,11 @@ cli
             'Critique disabled: diffs will not be auto-uploaded to critique.work',
           )
         }
+        if (options.skipFooterMentions) {
+          cliLogger.log(
+            'Footer mentions disabled: final session footers will not mention thread creators',
+          )
+        }
         if (options.noAutoUpgrade) {
           cliLogger.log(
             'Auto-upgrade disabled: kimaki will not check for updates on startup',
@@ -339,6 +386,12 @@ cli
             'Anonymous product analytics disabled (--no-analytics)',
           )
         }
+        if (opencodeHostname) {
+          cliLogger.log(`OpenCode server hostname: ${opencodeHostname}`)
+        }
+        if (opencodePort !== undefined) {
+          cliLogger.log(`OpenCode server port: ${opencodePort}`)
+        }
 
         if (options.installUrl) {
           await printDiscordInstallUrlAndExit({

package/src/commands/abort.ts

@@ -7,7 +7,7 @@ import {
   type ThreadChannel,
 } from 'discord.js'
 import type { CommandContext } from './types.js'
-import { getThreadSession } from '../database.js'
+import { cancelSessionSleepForThread, getThreadSession } from '../database.js'
 import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js'
 import {
   resolveWorkingDirectory,
@@ -66,6 +66,11 @@ export async function handleAbortCommand({
     return
   }
 
+  // Aborting is an explicit "stop waiting" from the user, and it never goes
+  // through enqueueIncoming, so cancel any pending sleep here too. Otherwise the
+  // wake would still fire later and restart a session the user just stopped.
+  await cancelSessionSleepForThread({ threadId: channel.id })
+
   // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
   const runtime = getRuntime(channel.id)
   if (runtime) {

package/src/commands/action-buttons.ts

@@ -19,6 +19,7 @@ import {
   sendThreadMessage,
 } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import { QUEUE_PREFIX } from '../message-formatting.js'
 import { notifyError } from '../sentry.js'
 import {
   getOrCreateRuntime,
@@ -331,7 +332,7 @@ export async function handleActionButton(
 
   await sendThreadMessage(
     thread,
-    `» **${username}:** ${button.label}`,
+    `${QUEUE_PREFIX}**${username}:** ${button.label}`,
   )
 
   try {