kimaki 0.28.0 → 0.30.0

package/src/cli-commands/thread.ts

@@ -0,0 +1,86 @@
+import { goke } from 'goke'
+import { z } from 'zod'
+import { createLogger, LogPrefix } from '../logger.js'
+import { initDatabase } from '../discord-bot.js'
+import { createDiscordRest } from '../discord-urls.js'
+import { EXIT_NO_RESTART, resolveBotCredentials } from '../cli-runner.js'
+import { listDiscordChannelThreads } from '../list-channel-threads.js'
+
+const cliLogger = createLogger(LogPrefix.CLI)
+const cli = goke()
+
+cli
+  .command(
+    'thread list',
+    'List Discord threads in a channel. Use this to find a thread on another computer, then send with --thread.',
+  )
+  .option('-c, --channel <channelId>', 'Discord channel ID')
+  .option('--json', 'Output as JSON')
+  .option(
+    '--limit <n>',
+    z.number().default(50).describe('Maximum threads to show'),
+  )
+  .example('kimaki thread list --channel 123456789012345678')
+  .example('kimaki thread list --channel 123456789012345678 --json')
+  .action(async (options, { console, process }) => {
+    try {
+      if (!options.channel) {
+        cliLogger.error(
+          'Channel ID is required. Use --channel <channelId>. Find remote channels with `kimaki project list --all --json`.',
+        )
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      await initDatabase()
+      const { token: botToken } = await resolveBotCredentials({})
+      const rest = createDiscordRest(botToken)
+      const listed = await listDiscordChannelThreads({
+        rest,
+        channelId: options.channel,
+      })
+      if (!listed.ok) {
+        cliLogger.error(listed.error.message)
+        process.exit(EXIT_NO_RESTART)
+        return
+      }
+
+      const limited = listed.threads.slice(0, options.limit)
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            limited.map((thread) => ({
+              thread_id: thread.id,
+              name: thread.name,
+              channel_id: thread.parentId,
+              guild_id: thread.guildId,
+              archived: thread.archived,
+              archive_state: thread.archiveState,
+              last_message_id: thread.lastMessageId,
+            })),
+            null,
+            2,
+          ),
+        )
+        process.exit(0)
+      }
+
+      if (limited.length === 0) {
+        console.log(`No threads found in channel ${options.channel}`)
+        process.exit(0)
+      }
+
+      for (const thread of limited) {
+        const archivedTag = thread.archived ? ' [archived]' : ''
+        console.log(`${thread.id} | ${thread.name}${archivedTag}`)
+      }
+      process.exit(0)
+    } catch (error) {
+      cliLogger.error(
+        'Error:',
+        error instanceof Error ? error.stack : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
+export default cli

package/src/cli-parsing.test.ts

@@ -58,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').option('--skip-footer-mentions', 'Do not mention the thread creator in final footers')",
+    "cli.command('', 'bot').option('--no-analytics', 'Disable analytics').option('--enable-footer-mentions', '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(';')
@@ -291,14 +291,14 @@ describe('goke CLI ID parsing', () => {
       'node',
       'kimaki',
       '--no-analytics',
-      '--skip-footer-mentions',
+      '--enable-footer-mentions',
     ])
 
     expect(result.options).toMatchInlineSnapshot(`
       {
         "--": [],
+        "enableFooterMentions": true,
         "noAnalytics": true,
-        "skipFooterMentions": true,
       }
     `)
   })

package/src/cli-runner.ts

@@ -28,6 +28,7 @@ import {
   initDatabase,
   getChannelDirectory,
   startDiscordBot,
+  registerBotLifecycleHandlers,
   initializeOpencodeForDirectory,
   assertCompatibleOpencodeVersion,
   createProjectChannels,
@@ -1638,6 +1639,9 @@ export async function run({
     cliLogger.error('Failed to start hrana server:', hranaResult.message)
     process.exit(EXIT_NO_RESTART)
   }
+  // We own the lock port from here on. Stop signals must release it in every
+  // startup phase (Discord login, channel reconcile), not only after ready.
+  registerBotLifecycleHandlers()
 
   // Initialize database (connects to hrana server via HTTP)
   await initDatabase()
@@ -1803,6 +1807,10 @@ export async function run({
     }
     process.exit(EXIT_NO_RESTART)
   }
+  // Stop signal during Discord login: shutdown owns the process now.
+  if (global.shuttingDown) {
+    return
+  }
   await setBotToken(appId, token)
 
    // In gateway mode the bot only sees guilds the user has installed
@@ -1842,6 +1850,9 @@ export async function run({
     // Start bot immediately — channel sync happens in the background.
     cliLogger.log('Starting Discord bot...')
     await startDiscordBot({ token, appId, discordClient, useWorktrees })
+    if (global.shuttingDown) {
+      return
+    }
     cliLogger.log('Discord bot is running!')
 
     // Background channel sync + role reconciliation + default channel creation.

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*
+        -# *using deterministic-provider/deterministic-v2*
         > caught-by-model
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000830>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)
         I can see you sent a message, but Discord did not include its text.

package/src/cli.ts

@@ -25,6 +25,7 @@ import projectCommands from './cli-commands/project.js'
 import sendCommands from './cli-commands/send.js'
 import sessionCommands from './cli-commands/session.js'
 import taskCommands from './cli-commands/task.js'
+import threadCommands from './cli-commands/thread.js'
 import userCommands from './cli-commands/user.js'
 import {
   EXIT_NO_RESTART,
@@ -75,8 +76,8 @@ cli
     'Disable automatic diff upload to critique.work in system prompts',
   )
   .option(
-    '--skip-footer-mentions',
-    'Do not mention the thread creator in final session footers',
+    '--enable-footer-mentions',
+    'Mention the thread creator in final session footers so they get a notification',
   )
   .option(
     '--auto-restart',
@@ -158,7 +159,7 @@ cli
       verbosity?: string
       mentionMode?: boolean
       noCritique?: boolean
-      skipFooterMentions?: boolean
+      enableFooterMentions?: boolean
       allowAllUsers?: boolean
       restrictDirectories?: boolean
       permissionTimeoutMinutes?: string
@@ -314,7 +315,7 @@ cli
           }),
           ...(options.mentionMode && { defaultMentionMode: true }),
           ...(options.noCritique && { critiqueEnabled: false }),
-          ...(options.skipFooterMentions && { footerMentionsEnabled: false }),
+          ...(options.enableFooterMentions && { footerMentionsEnabled: true }),
           ...(options.allowAllUsers && { allowAllUsers: true }),
           ...(options.restrictDirectories && { restrictExternalDirectories: true }),
           ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
@@ -365,9 +366,9 @@ cli
             'Critique disabled: diffs will not be auto-uploaded to critique.work',
           )
         }
-        if (options.skipFooterMentions) {
+        if (options.enableFooterMentions) {
           cliLogger.log(
-            'Footer mentions disabled: final session footers will not mention thread creators',
+            'Footer mentions enabled: final session footers will mention thread creators',
           )
         }
         if (options.noAutoUpgrade) {
@@ -423,6 +424,7 @@ cli.use(miscCommands)
 cli.use(sendCommands)
 cli.use(taskCommands)
 cli.use(projectCommands)
+cli.use(threadCommands)
 cli.use(userCommands)
 cli.use(sessionCommands)
 cli.use(maintenanceCommands)

package/src/commands/ask-question.ts

@@ -15,6 +15,7 @@ import { getOpencodeClient } from '../opencode.js'
 import { DiscordOperationError } from '../errors.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import { QUEUE_PREFIX } from '../message-formatting.js'
+import { getRuntime } from '../session-handler/thread-session-runtime.js'
 
 const logger = createLogger(LogPrefix.ASK_QUESTION)
 
@@ -298,51 +299,113 @@ export async function handleAskQuestionSelectMenu(
     `${QUEUE_PREFIX}**${username}:** ${answeredText}`,
   )
 
-  // Check if all questions are answered
-  if (areAllQuestionsAnswered(context)) {
-    // All questions answered - send result back to session
-    await submitQuestionAnswers(context)
+  // Check if all questions are answered. Claim the context synchronously
+  // (delete before awaiting submit) so two concurrent final selections for a
+  // multi-question tool cannot both submit and double-resume the session.
+  if (
+    areAllQuestionsAnswered(context)
+    && pendingQuestionContexts.get(contextHash) === context
+  ) {
     deletePendingQuestionContextsForRequest({
       threadId: context.thread.id,
       requestId: context.requestId,
     })
+    await submitQuestionAnswers(context)
+  }
+}
+
+/**
+ * Format collected answers as a plain-text summary the model can read when
+ * the run is resumed after an abort (e.g. `"Which option?"="Alpha"`).
+ *
+ * Known limitation: if the user had queued items via /queue during the pending
+ * question AND aborted the run from another opencode client, the first queued
+ * item may have already been handed off to opencode and can lose its ordering
+ * on resume. That rare combination needs a queue-handoff redesign; the common
+ * (no-queue) abort case is handled correctly.
+ */
+function formatQuestionAnswersText(context: PendingQuestionContext): string {
+  const parts = context.questions.map((q, i) => {
+    const answer = (context.answers[i] || []).join(', ') || 'Unanswered'
+    return `"${q.question}"="${answer}"`
+  })
+  return `Answers to your previous questions: ${parts.join(', ')}`
+}
+
+/** Resume the session by feeding the answers back as a new user prompt. */
+async function resumeSessionWithAnswers(
+  context: PendingQuestionContext,
+): Promise<void> {
+  const runtime = getRuntime(context.thread.id)
+  const resumed = await runtime?.resumeWithText({
+    text: formatQuestionAnswersText(context),
+  })
+  if (!resumed) {
+    await sendThreadMessage(
+      context.thread,
+      '✗ Failed to submit answers: session is no longer active',
+    )
   }
 }
 
 /**
  * Submit all collected answers back to the OpenCode session.
- * Uses the question.reply API to provide answers to the waiting tool.
+ *
+ * The decision is based on whether the session still has a live run:
+ *
+ * - Busy: a live run is parked on the question. Reply so it continues.
+ * - Idle: the run was aborted (from this or another opencode client). Replying
+ *   would resolve a dead run and the session would never continue, so resume it
+ *   with the answers as a fresh prompt instead.
+ *
+ * Note: `question.list` is not a reliable signal here. After an abort the
+ * question request can stay in the pending list but orphaned (no run awaiting
+ * it), so a reply would succeed yet the session would still not continue. The
+ * session busy state, derived from the event stream, is the accurate signal.
+ * The reply `.error` check is a safety net for the case where the request was
+ * actually removed while the session still looked busy.
  */
 async function submitQuestionAnswers(
   context: PendingQuestionContext,
 ): Promise<void> {
-  try {
-    const client = getOpencodeClient(context.directory)
-    if (!client) {
-      throw new Error('OpenCode server not found for directory')
-    }
+  const client = getOpencodeClient(context.directory)
+  if (!client) {
+    logger.error('OpenCode server not found for directory')
+    return
+  }
 
-    // Build answers array: each element is an array of selected labels for that question
-    const answers = context.questions.map((_, i) => {
-      return context.answers[i] || []
-    })
+  const runtime = getRuntime(context.thread.id)
 
-    await client.question.reply({
-      requestID: context.requestId,
-      directory: context.directory,
-      answers,
-    })
+  if (runtime && !runtime.isBusy()) {
+    logger.log(
+      `Session ${context.sessionId} idle; resuming with answers for question ${context.requestId}`,
+    )
+    await resumeSessionWithAnswers(context)
+    return
+  }
+
+  const answers = context.questions.map((_, i) => {
+    return context.answers[i] || []
+  })
 
+  // throwOnError is off on this client, so failures come back in `.error`.
+  const replyResult = await client.question
+    .reply({ requestID: context.requestId, directory: context.directory, answers })
+    .catch((error) => ({ error }))
+
+  if (!replyResult.error) {
     logger.log(
       `Submitted answers for question ${context.requestId} in session ${context.sessionId}`,
     )
-  } catch (error) {
-    logger.error('Failed to submit answers:', error)
-    await sendThreadMessage(
-      context.thread,
-      `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    )
+    return
   }
+
+  // Reply failed (the request was removed while the session still looked busy).
+  // Resume so the answer still reaches the model.
+  logger.log(
+    `Reply failed for question ${context.requestId}; resuming session ${context.sessionId} with answers`,
+  )
+  await resumeSessionWithAnswers(context)
 }
 
 /**

package/src/commands/queue.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest'
+import {
+  buildQueueRemoveCustomId,
+  parseQueueRemoveCustomId,
+} from './queue.js'
+
+describe('queue remove custom id', () => {
+  test('round-trips thread and queue ids under Discord custom_id limit', () => {
+    const customId = buildQueueRemoveCustomId({
+      threadId: '1550106184055398531',
+      queueId: 'a1b2c3d4e5f60789',
+    })
+    expect(customId.length).toBeLessThanOrEqual(100)
+    expect(parseQueueRemoveCustomId(customId)).toEqual({
+      threadId: '1550106184055398531',
+      queueId: 'a1b2c3d4e5f60789',
+    })
+  })
+})

package/src/commands/queue.ts

@@ -7,10 +7,11 @@ import {
   ButtonStyle,
   ChannelType,
   MessageFlags,
+  type ButtonInteraction,
   type ThreadChannel,
 } from 'discord.js'
 import type { AutocompleteContext, CommandContext } from './types.js'
-import { getThreadSession } from '../database.js'
+import { deleteThreadQueueItem, getThreadSession } from '../database.js'
 import {
   resolveWorkingDirectory,
   SILENT_MESSAGE_FLAGS,
@@ -19,61 +20,128 @@ import {
   getOrCreateRuntime,
   getRuntime,
 } from '../session-handler/thread-session-runtime.js'
-import {
-  buildHtmlActionCustomId,
-  registerHtmlAction,
-} from '../html-actions.js'
 import { createLogger, LogPrefix } from '../logger.js'
-import { QUEUE_PREFIX } from '../message-formatting.js'
+import { asSystemLine, QUEUE_PREFIX } from '../message-formatting.js'
 import { store } from '../store.js'
 
 const logger = createLogger(LogPrefix.QUEUE)
 
+export const QUEUE_REMOVE_CUSTOM_ID_PREFIX = 'queue_remove:'
+
+async function deleteThreadQueueItemWithoutRuntime(queueId: string) {
+  const row = await deleteThreadQueueItem(queueId).catch((error) => {
+    logger.error(
+      `[QUEUE] Failed to delete persisted queue item ${queueId}: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return undefined
+  })
+  if (!row) {
+    return undefined
+  }
+  try {
+    const parsed = JSON.parse(row.payload_json) as {
+      prompt?: string
+      username?: string
+      command?: { name: string }
+    }
+    return {
+      prompt: typeof parsed.prompt === 'string' ? parsed.prompt : '',
+      username: typeof parsed.username === 'string' ? parsed.username : '',
+      command: parsed.command,
+    }
+  } catch {
+    return { prompt: '', username: '' }
+  }
+}
+
+export function buildQueueRemoveCustomId({
+  threadId,
+  queueId,
+}: {
+  threadId: string
+  queueId: string
+}): string {
+  return `${QUEUE_REMOVE_CUSTOM_ID_PREFIX}${threadId}:${queueId}`
+}
+
+export function parseQueueRemoveCustomId(customId: string): {
+  threadId: string
+  queueId: string
+} | undefined {
+  if (!customId.startsWith(QUEUE_REMOVE_CUSTOM_ID_PREFIX)) {
+    return undefined
+  }
+  const rest = customId.slice(QUEUE_REMOVE_CUSTOM_ID_PREFIX.length)
+  const separator = rest.indexOf(':')
+  if (separator <= 0 || separator >= rest.length - 1) {
+    return undefined
+  }
+  return {
+    threadId: rest.slice(0, separator),
+    queueId: rest.slice(separator + 1),
+  }
+}
+
 function buildQueueRemoveRow({
   threadId,
   queueId,
-  position,
 }: {
   threadId: string
   queueId: string
-  position?: number
 }) {
-  const actionId = registerHtmlAction({
-    ownerKey: `queue-remove:${threadId}:${queueId}`,
-    threadId,
-    run: async ({ interaction }) => {
-      const removed = getRuntime(threadId)?.removeQueueItemById(queueId)
-      if (!removed) {
-        await interaction.editReply({
-          content: position
-            ? `Queued message at position ${position} is no longer in the queue`
-            : 'Queued message is no longer in the queue',
-          components: [],
-        })
-        return
-      }
-
-      const label = removed.command
-        ? `/${removed.command.name}`
-        : removed.prompt.slice(0, 120)
-      await interaction.editReply({
-        content: `Removed queued message${position ? ` (was position ${position})` : ''}: ${label}`,
-        components: [],
-      })
-      logger.log(
-        `[QUEUE] User ${interaction.user.displayName} removed queued item ${queueId} in thread ${threadId}`,
-      )
-    },
-  })
-
   return new ActionRowBuilder<ButtonBuilder>().addComponents(
     new ButtonBuilder()
-      .setCustomId(buildHtmlActionCustomId(actionId))
+      .setCustomId(buildQueueRemoveCustomId({ threadId, queueId }))
       .setLabel('Remove from queue')
       .setStyle(ButtonStyle.Secondary),
   )
 }
 
+export async function handleQueueRemoveButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const parsed = parseQueueRemoveCustomId(interaction.customId)
+  if (!parsed) {
+    await interaction.reply({
+      content: 'Invalid queue remove button',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (interaction.channelId && interaction.channelId !== parsed.threadId) {
+    await interaction.reply({
+      content: 'This queue button does not belong to this thread',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await interaction.deferUpdate()
+  const runtime = getRuntime(parsed.threadId)
+  const removed = runtime
+    ? await runtime.removeQueueItemById(parsed.queueId)
+    : await deleteThreadQueueItemWithoutRuntime(parsed.queueId)
+  if (!removed) {
+    await interaction.editReply({
+      content: asSystemLine('Queued message is no longer in the queue'),
+      components: [],
+    })
+    return
+  }
+
+  const label = removed.command
+    ? `/${removed.command.name}`
+    : removed.prompt.slice(0, 120)
+  await interaction.editReply({
+    content: asSystemLine(`Removed queued message: ${label}`),
+    components: [],
+  })
+  logger.log(
+    `[QUEUE] User ${interaction.user.displayName} removed queued item ${parsed.queueId} in thread ${parsed.threadId}`,
+  )
+}
+
 export async function handleQueueCommand({
   command,
   appId,
@@ -143,14 +211,13 @@ export async function handleQueueCommand({
   })
 
   if (enqueueResult.queued && enqueueResult.queueId) {
-    const responseText = `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+    const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`)
     await command.reply({
       content: responseText,
       components: [
         buildQueueRemoveRow({
           threadId: thread.id,
           queueId: enqueueResult.queueId,
-          position: enqueueResult.position,
         }),
       ],
       flags: SILENT_MESSAGE_FLAGS,
@@ -205,7 +272,7 @@ export async function handleClearQueueCommand({
   }
 
   if (position !== undefined) {
-    const removed = runtime?.removeQueuePosition(position)
+    const removed = await runtime?.removeQueuePosition(position)
     if (!removed) {
       await command.reply({
         content: `No queued message at position ${position}`,
@@ -215,7 +282,7 @@ export async function handleClearQueueCommand({
     }
 
     await command.reply({
-      content: `Cleared queued message at position ${position}`,
+      content: asSystemLine(`Cleared queued message at position ${position}`),
       flags: SILENT_MESSAGE_FLAGS,
     })
 
@@ -225,7 +292,7 @@ export async function handleClearQueueCommand({
     return
   }
 
-  const cleared = runtime?.clearQueue() ?? []
+  const cleared = await runtime?.clearQueue() ?? []
 
   const lines = cleared.map((item, i) => {
     const label = item.command
@@ -239,7 +306,7 @@ export async function handleClearQueueCommand({
   }
 
   await command.reply({
-    content: `Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`,
+    content: asSystemLine(`Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`),
     flags: SILENT_MESSAGE_FLAGS,
   })
 
@@ -335,14 +402,13 @@ export async function handleQueueCommandCommand({
   })
 
   if (enqueueResult.queued && enqueueResult.queueId) {
-    const responseText = `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+    const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`)
     await command.reply({
       content: responseText,
       components: [
         buildQueueRemoveRow({
           threadId: thread.id,
           queueId: enqueueResult.queueId,
-          position: enqueueResult.position,
         }),
       ],
       flags: SILENT_MESSAGE_FLAGS,

package/src/commands/restart-opencode-server.ts

@@ -20,7 +20,10 @@ import {
   SILENT_MESSAGE_FLAGS,
 } from '../discord-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
-import { disposeRuntimesForDirectory } from '../session-handler/thread-session-runtime.js'
+import {
+  disposeRuntimesForDirectory,
+  restorePersistedLocalQueues,
+} from '../session-handler/thread-session-runtime.js'
 import { registerCommands, type AgentInfo } from '../discord-command-registration.js'
 
 const logger = createLogger(LogPrefix.OPENCODE)
@@ -104,6 +107,14 @@ export async function handleRestartOpencodeServerCommand({
     content: `Opencode server **restarted** successfully${abortMsg}. Re-registering slash commands...`,
   })
   logger.log('[RESTART] Shared opencode server restarted')
+  await restorePersistedLocalQueues({
+    discordClient: command.client,
+    appId,
+  }).catch((error) => {
+    logger.warn(
+      `[RESTART] Failed to restore persisted queues: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  })
 
   // Re-register Discord slash commands after restart so new/changed
   // commands, agents, and plugins are picked up immediately.