kimaki 0.4.82 → 0.4.84

package/src/opencode.ts

@@ -67,6 +67,10 @@ import {
 
 const opencodeLogger = createLogger(LogPrefix.OPENCODE)
 
+// Tracks directories that have been initialized, to avoid repeated log spam
+// from the external sync polling loop.
+const initializedDirectories = new Set<string>()
+
 const STARTUP_STDERR_TAIL_LIMIT = 30
 const STARTUP_STDERR_LINE_MAX_LENGTH = 120
 const STARTUP_ERROR_REASON_MAX_LENGTH = 1500
@@ -514,6 +518,20 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     opencodeLogger.warn(kimakiShimDirectory.message)
   }
   const gatewayToken = store.getState().gatewayToken
+  const vitestOpencodeEnv = (() => {
+    if (process.env.KIMAKI_VITEST !== '1') {
+      return {}
+    }
+    const root = path.join(getDataDir(), 'opencode-vitest-home')
+    return {
+      OPENCODE_TEST_HOME: root,
+      OPENCODE_CONFIG_DIR: path.join(root, '.opencode-kimaki'),
+      XDG_CONFIG_HOME: path.join(root, '.config'),
+      XDG_DATA_HOME: path.join(root, '.local', 'share'),
+      XDG_CACHE_HOME: path.join(root, '.cache'),
+      XDG_STATE_HOME: path.join(root, '.local', 'state'),
+    }
+  })()
 
   const serverProcess = spawn(
     spawnCommand,
@@ -574,6 +592,7 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
         ...(process.env.KIMAKI_SENTRY_DSN && {
           KIMAKI_SENTRY_DSN: process.env.KIMAKI_SENTRY_DSN,
         }),
+        ...vitestOpencodeEnv,
         ...(pathEnv && { [pathEnvKey]: pathEnv }),
       },
     },
@@ -644,10 +663,12 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     clientCache.clear()
     notifyServerLifecycle({ type: 'stopped' })
 
-    // Intentional kills (SIGTERM from cleanup/restart) should not trigger
-    // auto-restart. Only unexpected crashes (non-zero exit without signal)
-    // get retried.
-    if (signal === 'SIGTERM') {
+    // Intentional kills should not trigger auto-restart:
+    // - SIGTERM from our cleanup/restart code
+    // - SIGINT propagated from Ctrl+C (parent process group signal)
+    // - any exit during bot shutdown (shuttingDown flag)
+    // Only unexpected crashes (non-zero exit without signal) get retried.
+    if (signal === 'SIGTERM' || signal === 'SIGINT' || (global as any).shuttingDown) {
       serverRetryCount = 0
       return
     }
@@ -781,9 +802,12 @@ export async function initializeOpencodeForDirectory(
     return server
   }
 
-  opencodeLogger.log(
-    `Using shared server on port ${server.port} for directory: ${directory}`,
-  )
+  if (!initializedDirectories.has(directory)) {
+    initializedDirectories.add(directory)
+    opencodeLogger.log(
+      `Using shared server on port ${server.port} for directory: ${directory}`,
+    )
+  }
 
   return () => {
     if (!singleServer) {

package/src/queue-advanced-e2e-setup.ts

@@ -330,6 +330,42 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     },
   }
 
+  // Question tool for select+queue drain test: model asks a question via dropdown,
+  // user answers via select menu while a message is queued.
+  const questionSelectQueueMatcher: DeterministicMatcher = {
+    id: 'question-select-queue-marker',
+    priority: 107,
+    when: {
+      lastMessageRole: 'user',
+      latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        {
+          type: 'tool-call',
+          toolCallId: 'question-select-queue-call',
+          toolName: 'question',
+          input: JSON.stringify({
+            questions: [{
+              question: 'How to proceed?',
+              header: 'Select action',
+              options: [
+                { label: 'Alpha', description: 'Alpha option' },
+                { label: 'Beta', description: 'Beta option' },
+              ],
+            }],
+          }),
+        },
+        {
+          type: 'finish',
+          finishReason: 'tool-calls',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+    },
+  }
+
   // Model responds with text + tool call, then after tool result the
   // follow-up matcher responds with text. This creates two assistant messages:
   // first with finish="tool-calls" + completed, second with finish="stop".
@@ -389,6 +425,59 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     },
   }
 
+  const undoFileMatcher: DeterministicMatcher = {
+    id: 'undo-file-marker',
+    priority: 111,
+    when: {
+      lastMessageRole: 'user',
+      latestUserTextIncludes: 'UNDO_FILE_MARKER',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'undo-file-text' },
+        { type: 'text-delta', id: 'undo-file-text', delta: 'creating undo file' },
+        { type: 'text-end', id: 'undo-file-text' },
+        {
+          type: 'tool-call',
+          toolCallId: 'undo-file-bash',
+          toolName: 'bash',
+          input: JSON.stringify({
+            command: 'mkdir -p tmp && printf created > tmp/undo-marker.txt',
+            description: 'Create undo marker file',
+          }),
+        },
+        {
+          type: 'finish',
+          finishReason: 'tool-calls',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+    },
+  }
+
+  const undoFileFollowupMatcher: DeterministicMatcher = {
+    id: 'undo-file-followup',
+    priority: 112,
+    when: {
+      latestUserTextIncludes: 'UNDO_FILE_MARKER',
+      rawPromptIncludes: 'creating undo file',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'undo-file-followup' },
+        { type: 'text-delta', id: 'undo-file-followup', delta: 'undo file created' },
+        { type: 'text-end', id: 'undo-file-followup' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+    },
+  }
+
   // Multi-step tool chain: model emits text + 3 parallel tool calls in one
   // response (finish="tool-calls"). All tools complete, then the follow-up
   // matcher responds with final text (finish="stop"). This creates 2 assistant
@@ -601,10 +690,13 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     pluginTimeoutSleepMatcher,
     actionButtonClickFollowupMatcher,
     questionToolMatcher,
+    questionSelectQueueMatcher,
     permissionTypingMatcher,
     permissionTypingFollowupMatcher,
     multiToolMatcher,
     multiToolFollowupMatcher,
+    undoFileMatcher,
+    undoFileFollowupMatcher,
     multiStepChainInitMatcher,
     multiStepChainStep2Matcher,
     multiStepChainStep3Matcher,

package/src/queue-advanced-permissions-typing.e2e.test.ts

@@ -62,7 +62,7 @@ describe('queue advanced: typing around permissions', () => {
 
       const th = ctx.discord.thread(thread.id)
 
-      await th.waitForTypingEvent({ timeout: 1_000 })
+      await th.waitForTypingEvent({ timeout: 4_000 })
 
       const pending = await waitForPendingPermission({
         threadId: thread.id,
@@ -181,7 +181,7 @@ describe('queue advanced: typing around permissions', () => {
         discord: ctx.discord,
         threadId: thread.id,
         text: 'Permission dismissed - user sent a new message.',
-        timeout: 4_000,
+        timeout: 8_000,
       })
 
       await waitForBotReplyAfterUserMessage({
@@ -189,7 +189,7 @@ describe('queue advanced: typing around permissions', () => {
         threadId: thread.id,
         userId: TEST_USER_ID,
         userMessageIncludes: 'post-permission-user-message',
-        timeout: 4_000,
+        timeout: 8_000,
       })
 
       await waitForBotMessageContaining({
@@ -198,13 +198,13 @@ describe('queue advanced: typing around permissions', () => {
         userId: TEST_USER_ID,
         text: 'ok',
         afterUserMessageIncludes: 'post-permission-user-message',
-        timeout: 4_000,
+        timeout: 8_000,
       })
 
       await waitForFooterMessage({
         discord: ctx.discord,
         threadId: thread.id,
-        timeout: 4_000,
+        timeout: 8_000,
         afterMessageIncludes: 'ok',
         afterAuthorId: ctx.discord.botUserId,
       })

package/src/queue-advanced-typing.e2e.test.ts

@@ -72,14 +72,11 @@ e2eTest('queue advanced: typing lifecycle', () => {
       })
 
       const timeline = await th.text({ showTyping: true })
-      expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        Reply with exactly: typing-stop-normal
-        [bot typing]
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
+      expect(timeline).toContain('Reply with exactly: typing-stop-normal')
+      expect(timeline).toContain('⬥ ok')
+      expect(timeline).toContain('*project ⋅ main ⋅')
+      const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
+      expect(typingCount).toBeGreaterThanOrEqual(1)
       expect(replyIndex).toBeGreaterThanOrEqual(0)
       expect(footerIndex).toBeGreaterThan(replyIndex)
       expect(messages[footerIndex]).toBeDefined()
@@ -175,20 +172,10 @@ e2eTest('queue advanced: typing lifecycle', () => {
       })
 
       const timeline = await th.text({ showTyping: true })
-      expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        Reply with exactly: typing-thread-reply-setup
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (queue-advanced-tester)
-        TYPING_REPULSE_MARKER
-        [bot typing]
-        --- from: assistant (TestBot)
-        ⬥ repulse-first
-        [bot typing]
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
+      expect(timeline).toContain('TYPING_REPULSE_MARKER')
+      expect(timeline).toContain('⬥ repulse-first')
+      const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
+      expect(typingCount).toBeGreaterThanOrEqual(2)
 
       const followupUserIndex = messages.findIndex((message) => {
         return message.author.id === TEST_USER_ID

package/src/queue-question-select-drain.e2e.test.ts

@@ -0,0 +1,149 @@
+// E2e test: queued message must drain after the user answers a pending question
+// via the Discord dropdown select menu. Reproduces a bug where answering via
+// select (not text) leaves queued messages stuck because the session continues
+// processing after the answer and may enter another blocking state.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+import { pendingQuestionContexts } from './commands/ask-question.js'
+
+const TEXT_CHANNEL_ID = '200000000000001030'
+
+async function waitForPendingQuestion({
+  threadId,
+  timeoutMs,
+}: {
+  threadId: string
+  timeoutMs: number
+}): Promise<{ contextHash: string }> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+      return context.thread.id === threadId
+    })
+    if (entry) {
+      return { contextHash: entry[0] }
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 100)
+    })
+  }
+  throw new Error('Timed out waiting for pending question context')
+}
+
+describe('queue drain after question select answer', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-question-select-drain',
+    dirName: 'qa-question-select-drain',
+    username: 'question-select-tester',
+  })
+
+  test(
+    'queued message drains after answering question via dropdown select',
+    async () => {
+      // 1. Send a message that triggers the question tool
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'QUESTION_SELECT_QUEUE_MARKER',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'QUESTION_SELECT_QUEUE_MARKER'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      // 2. Wait for the question dropdown to appear
+      const pending = await waitForPendingQuestion({
+        threadId: thread.id,
+        timeoutMs: 4_000,
+      })
+      expect(pending.contextHash).toBeTruthy()
+
+      // Verify dropdown message appeared
+      const questionMessages = await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'How to proceed?',
+        timeout: 4_000,
+      })
+      const questionMsg = questionMessages.find((m) => {
+        return m.content.includes('How to proceed?')
+      })!
+      expect(questionMsg).toBeTruthy()
+
+      // 3. Queue a message while question is pending
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
+        })
+
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 4_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+
+      // 4. Answer the question via dropdown select (pick first option "Alpha")
+      const interaction = await th.user(TEST_USER_ID).selectMenu({
+        messageId: questionMsg.id,
+        customId: `ask_question:${pending.contextHash}:0`,
+        values: ['0'],
+      })
+
+      await th.waitForInteractionAck({
+        interactionId: interaction.id,
+        timeout: 4_000,
+      })
+
+      // 5. Queued message should be handed off to OpenCode's own prompt queue
+      //    after the question reply, so the dispatch indicator appears without
+      //    waiting for a later natural idle.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: '» **question-select-tester:** Reply with exactly: post-question-drain',
+        timeout: 4_000,
+      })
+
+      // 6. Wait for footer from the drained queued message
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: '» **question-select-tester:**',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        » **question-select-tester:** Reply with exactly: post-question-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
+})

package/src/schema.sql

@@ -2,6 +2,7 @@
 CREATE TABLE IF NOT EXISTS "thread_sessions" (
     "thread_id" TEXT NOT NULL PRIMARY KEY,
     "session_id" TEXT NOT NULL,
+    "source" TEXT NOT NULL DEFAULT 'kimaki',
     "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 CREATE TABLE IF NOT EXISTS "session_events" (

package/src/session-handler/event-stream-state.test.ts

@@ -16,6 +16,7 @@ import {
   getLatestAssistantMessageIdForLatestUserTurn,
   getLatestRunInfo,
   hasAssistantMessageCompletedBefore,
+  doesLatestUserTurnHaveNaturalCompletion,
   isAssistantMessageInLatestUserTurn,
   isAssistantMessageNaturalCompletion,
   isSessionBusy,
@@ -240,7 +241,11 @@ describe('session-concurrent-messages-serialized', () => {
     sessionId,
   })
 
-  test('fixture ends idle and latest assistant completed naturally', () => {
+  test('fixture latest turn is still incomplete even though an older turn completed', () => {
+    expect(doesLatestUserTurnHaveNaturalCompletion({
+      events,
+      sessionId,
+    })).toBe(false)
     if (!latestAssistantMessageId) {
       throw new Error('Expected latest assistant message')
     }
@@ -249,7 +254,7 @@ describe('session-concurrent-messages-serialized', () => {
       sessionId,
       messageId: latestAssistantMessageId,
     })
-    expect(isAssistantMessageNaturalCompletion({ message })).toBe(true)
+    expect(message.id).toBe(latestAssistantMessageId)
   })
 })
 

package/src/session-handler/event-stream-state.ts

@@ -164,6 +164,7 @@ export function getLatestUserMessage({
   upToIndex?: number
 }): UserMessage | undefined {
   const end = upToIndex ?? events.length - 1
+  let latestUserMessage: UserMessage | undefined
   for (let i = end; i >= 0; i--) {
     const entry = events[i]
     if (!entry) {
@@ -177,9 +178,15 @@ export function getLatestUserMessage({
     if (info.sessionID !== sessionId || info.role !== 'user') {
       continue
     }
-    return info
+    if (!latestUserMessage) {
+      latestUserMessage = info
+      continue
+    }
+    if (info.time.created > latestUserMessage.time.created) {
+      latestUserMessage = info
+    }
   }
-  return undefined
+  return latestUserMessage
 }
 
 export function getCurrentTurnStartTime({
@@ -314,6 +321,9 @@ export function getLatestAssistantMessageIdForLatestUserTurn({
     return undefined
   }
   const end = upToIndex ?? events.length - 1
+  let latestAssistantMessage:
+    | Extract<OpenCodeMessage, { role: 'assistant' }>
+    | undefined
   for (let i = end; i >= 0; i--) {
     const entry = events[i]
     if (!entry) {
@@ -327,11 +337,99 @@ export function getLatestAssistantMessageIdForLatestUserTurn({
     if (info.sessionID !== sessionId || info.role !== 'assistant') {
       continue
     }
-    if (info.parentID === latestUserMessage.id) {
-      return info.id
+    if (info.parentID !== latestUserMessage.id) {
+      continue
+    }
+    if (!latestAssistantMessage) {
+      latestAssistantMessage = info
+      continue
+    }
+    if (info.time.created > latestAssistantMessage.time.created) {
+      latestAssistantMessage = info
     }
   }
-  return undefined
+  return latestAssistantMessage?.id
+}
+
+type EventBufferedAssistantMessage = AssistantMessage & {
+  partsSummary?: Array<{ id: string; type: string }>
+}
+
+function hasRenderablePartSummary(message: EventBufferedAssistantMessage): boolean {
+  if (!('partsSummary' in message) || !Array.isArray(message.partsSummary)) {
+    return false
+  }
+  return message.partsSummary.some((part) => {
+    return part.type === 'text' || part.type === 'tool'
+  })
+}
+
+function hasAssistantPartEvidence({
+  events,
+  sessionId,
+  messageId,
+  upToIndex,
+}: {
+  events: EventBufferEntry[]
+  sessionId: string
+  messageId: string
+  upToIndex?: number
+}): boolean {
+  const end = upToIndex ?? events.length - 1
+  for (let i = end; i >= 0; i--) {
+    const entry = events[i]
+    if (!entry) {
+      continue
+    }
+    const event = entry.event
+    if (event.type === 'message.updated') {
+      const info = event.properties.info as EventBufferedAssistantMessage
+      if (info.sessionID !== sessionId || info.role !== 'assistant' || info.id !== messageId) {
+        continue
+      }
+      if (hasRenderablePartSummary(info)) {
+        return true
+      }
+      continue
+    }
+    if (event.type !== 'message.part.updated') {
+      continue
+    }
+    const { part } = event.properties
+    if (part.messageID !== messageId) {
+      continue
+    }
+    if (part.type === 'text' || part.type === 'tool') {
+      return true
+    }
+  }
+  return false
+}
+
+function hasAssistantStepFinished({
+  events,
+  messageId,
+  upToIndex,
+}: {
+  events: EventBufferEntry[]
+  messageId: string
+  upToIndex?: number
+}): boolean {
+  const end = upToIndex ?? events.length - 1
+  for (let i = end; i >= 0; i--) {
+    const entry = events[i]
+    if (!entry || entry.event.type !== 'message.part.updated') {
+      continue
+    }
+    const { part } = entry.event.properties
+    if (part.messageID !== messageId) {
+      continue
+    }
+    if (part.type === 'step-finish') {
+      return true
+    }
+  }
+  return false
 }
 
 export function doesLatestUserTurnHaveNaturalCompletion({
@@ -353,6 +451,7 @@ export function doesLatestUserTurnHaveNaturalCompletion({
   }
 
   const end = upToIndex ?? events.length - 1
+  let latestAssistantMessage: EventBufferedAssistantMessage | undefined
   for (let i = end; i >= 0; i--) {
     const entry = events[i]
     if (!entry) {
@@ -369,10 +468,32 @@ export function doesLatestUserTurnHaveNaturalCompletion({
     if (info.id !== latestAssistantMessageId) {
       continue
     }
-    return isAssistantMessageNaturalCompletion({ message: info })
+    latestAssistantMessage = info as EventBufferedAssistantMessage
+    if (isAssistantMessageNaturalCompletion({ message: info })) {
+      return true
+    }
+    break
   }
 
-  return false
+  if (!latestAssistantMessage) {
+    return false
+  }
+  if (latestAssistantMessage.error) {
+    return false
+  }
+  if (latestAssistantMessage.finish === 'tool-calls') {
+    return false
+  }
+  return hasAssistantStepFinished({
+    events,
+    messageId: latestAssistantMessageId,
+    upToIndex,
+  }) && hasAssistantPartEvidence({
+    events,
+    sessionId,
+    messageId: latestAssistantMessageId,
+    upToIndex,
+  })
 }
 
 export function isAssistantMessageInLatestUserTurn({

package/src/session-handler/thread-runtime-state.ts

@@ -42,6 +42,11 @@ export type QueuedMessage = {
   // Raw permission rule strings ("tool:action" or "tool:pattern:action").
   // Parsed and merged into session permissions on creation.
   permissions?: string[]
+  // Discord message ID and thread ID of the source message. Embedded in
+  // <discord-user> synthetic context so the external sync loop can detect
+  // messages that originated from Discord and skip re-mirroring them.
+  sourceMessageId?: string
+  sourceThreadId?: string
   // Tracking fields for scheduled tasks. Stored in the DB via
   // setSessionStartSource() after the session is created, so the session
   // list can show which sessions were started by scheduled tasks.