kimaki 0.4.76 → 0.4.78

package/src/queue-advanced-model-switch.e2e.test.ts

@@ -0,0 +1,383 @@
+// E2e test for /model switch behavior through interrupt recovery.
+// Reproduces fallback where interrupt plugin resume can run without model,
+// causing default opencode.json model to be used after switching session model.
+
+import { describe, test, expect } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import type { DigitalDiscord } from 'discord-digital-twin/src'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForBotReplyAfterUserMessage,
+  waitForFooterMessage,
+  waitForMessageById,
+} from './test-utils.js'
+import { getThreadState } from './session-handler/thread-runtime-state.js'
+import { getSessionModel } from './database.js'
+import { initializeOpencodeForDirectory } from './opencode.js'
+
+const TEXT_CHANNEL_ID = '200000000000001007'
+
+function getCustomIdFromInteractionData({
+  serializedComponents,
+  prefix,
+}: {
+  serializedComponents: string
+  prefix: string
+}): string {
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const customIdRegex = new RegExp(`\"custom_id\"\\s*:\\s*\"(${escapedPrefix}[^\"]+)\"`)
+  const match = serializedComponents.match(customIdRegex)
+  if (!match?.[1]) {
+    throw new Error(
+      `Could not find custom_id with prefix ${prefix} in components: ${serializedComponents}`,
+    )
+  }
+  return match[1]
+}
+
+async function waitForMessageComponentsWithCustomId({
+  discord,
+  threadId,
+  messageId,
+  customIdPrefix,
+  timeoutMs,
+}: {
+  discord: DigitalDiscord
+  threadId: string
+  messageId: string
+  customIdPrefix: string
+  timeoutMs: number
+}): Promise<string> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    const message = await waitForMessageById({
+      discord,
+      threadId,
+      messageId,
+      timeout: 1_000,
+    })
+    const serializedComponents = JSON.stringify(message.components)
+    if (serializedComponents.includes(customIdPrefix)) {
+      return serializedComponents
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 50)
+    })
+  }
+  throw new Error(
+    `Timed out waiting for custom_id prefix ${customIdPrefix} in message ${messageId}`,
+  )
+}
+
+async function waitForInteractionMessage({
+  getInteraction,
+  interactionId,
+  timeoutMs,
+}: {
+  getInteraction: (interactionId: string) => Promise<{
+    messageId: string | null
+    data: string | null
+  } | null>
+  interactionId: string
+  timeoutMs: number
+}): Promise<{ messageId: string; data: string }> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    const response = await getInteraction(interactionId)
+    if (response?.messageId) {
+      return {
+        messageId: response.messageId,
+        data: response.data || '',
+      }
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 50)
+    })
+  }
+  throw new Error(`Timed out waiting for interaction message ${interactionId}`)
+}
+
+describe('queue advanced: /model with interrupt recovery', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-model-switch-e2e',
+    dirName: 'qa-model-switch-e2e',
+    username: 'queue-model-switch-tester',
+  })
+
+  test(
+    'session model selected in /model survives interrupt-plugin resume path',
+    async () => {
+      const buildAgentDir = path.join(
+        ctx.directories.projectDirectory,
+        '.opencode',
+        'agent',
+      )
+      fs.mkdirSync(buildAgentDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(buildAgentDir, 'build.md'),
+        [
+          '---',
+          'name: build',
+          'description: Default build agent for deterministic model tests',
+          'model: deterministic-provider/deterministic-v2',
+          '---',
+          '',
+          'You are the default build agent.',
+          '',
+        ].join('\n'),
+      )
+
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: model-switcher-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: model-switcher-setup'
+        },
+      })
+      const th = ctx.discord.thread(thread.id)
+
+      await th.waitForBotReply({ timeout: 4_000 })
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      const modelCommand = await th.user(TEST_USER_ID).runSlashCommand({
+        name: 'model',
+      })
+      await th.waitForInteractionAck({
+        interactionId: modelCommand.id,
+        timeout: 4_000,
+      })
+
+      const providerStep = await waitForInteractionMessage({
+        getInteraction: (interactionId) => {
+          return th.getInteractionResponse(interactionId)
+        },
+        interactionId: modelCommand.id,
+        timeoutMs: 4_000,
+      })
+      const providerCustomId = getCustomIdFromInteractionData({
+        serializedComponents: await waitForMessageComponentsWithCustomId({
+          discord: ctx.discord,
+          threadId: thread.id,
+          messageId: providerStep.messageId,
+          customIdPrefix: 'model_provider:',
+          timeoutMs: 4_000,
+        }),
+        prefix: 'model_provider:',
+      })
+
+      const providerSelect = await th.user(TEST_USER_ID).selectMenu({
+        messageId: providerStep.messageId,
+        customId: providerCustomId,
+        values: ['deterministic-provider'],
+      })
+      await th.waitForInteractionAck({
+        interactionId: providerSelect.id,
+        timeout: 4_000,
+      })
+
+      const modelStep = await waitForInteractionMessage({
+        getInteraction: (interactionId) => {
+          return th.getInteractionResponse(interactionId)
+        },
+        interactionId: providerSelect.id,
+        timeoutMs: 4_000,
+      })
+      const modelCustomId = getCustomIdFromInteractionData({
+        serializedComponents: await waitForMessageComponentsWithCustomId({
+          discord: ctx.discord,
+          threadId: thread.id,
+          messageId: modelStep.messageId,
+          customIdPrefix: 'model_select:',
+          timeoutMs: 4_000,
+        }),
+        prefix: 'model_select:',
+      })
+
+      const modelSelect = await th.user(TEST_USER_ID).selectMenu({
+        messageId: modelStep.messageId,
+        customId: modelCustomId,
+        values: ['deterministic-v3'],
+      })
+      await th.waitForInteractionAck({
+        interactionId: modelSelect.id,
+        timeout: 4_000,
+      })
+
+      const maybeVariantOrScopeStep = await waitForInteractionMessage({
+        getInteraction: (interactionId) => {
+          return th.getInteractionResponse(interactionId)
+        },
+        interactionId: modelSelect.id,
+        timeoutMs: 4_000,
+      })
+
+      const maybeVariantOrScopeMessage = await waitForMessageById({
+        discord: ctx.discord,
+        threadId: thread.id,
+        messageId: maybeVariantOrScopeStep.messageId,
+        timeout: 4_000,
+      })
+      const maybeVariantOrScopeComponents = JSON.stringify(
+        maybeVariantOrScopeMessage.components,
+      )
+
+      const scopeStep = maybeVariantOrScopeComponents.includes('model_variant:')
+        ? await (async () => {
+            const variantCustomId = getCustomIdFromInteractionData({
+              serializedComponents: maybeVariantOrScopeComponents,
+              prefix: 'model_variant:',
+            })
+            const variantSelect = await th.user(TEST_USER_ID).selectMenu({
+              messageId: maybeVariantOrScopeStep.messageId,
+              customId: variantCustomId,
+              values: ['__none__'],
+            })
+            await th.waitForInteractionAck({
+              interactionId: variantSelect.id,
+              timeout: 4_000,
+            })
+            return waitForInteractionMessage({
+              getInteraction: (interactionId) => {
+                return th.getInteractionResponse(interactionId)
+              },
+              interactionId: variantSelect.id,
+              timeoutMs: 4_000,
+            })
+          })()
+        : maybeVariantOrScopeStep
+
+      const scopeCustomId = getCustomIdFromInteractionData({
+        serializedComponents: await waitForMessageComponentsWithCustomId({
+          discord: ctx.discord,
+          threadId: thread.id,
+          messageId: scopeStep.messageId,
+          customIdPrefix: 'model_scope:',
+          timeoutMs: 4_000,
+        }),
+        prefix: 'model_scope:',
+      })
+
+      const scopeSelect = await th.user(TEST_USER_ID).selectMenu({
+        messageId: scopeStep.messageId,
+        customId: scopeCustomId,
+        values: ['session'],
+      })
+      await th.waitForInteractionAck({
+        interactionId: scopeSelect.id,
+        timeout: 4_000,
+      })
+
+      const sessionId = getThreadState(thread.id)?.sessionId
+      expect(sessionId).toBeDefined()
+      if (!sessionId) {
+        throw new Error('Expected session id to be present after /model selection')
+      }
+      const sessionModel = await getSessionModel(sessionId)
+      expect(sessionModel?.modelId).toBe('deterministic-provider/deterministic-v3')
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+      })
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: model-switcher-followup',
+      })
+
+      await waitForBotReplyAfterUserMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        userMessageIncludes: 'model-switcher-followup',
+        timeout: 8_000,
+      })
+      const finalMessages = await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: 'model-switcher-followup',
+        afterAuthorId: TEST_USER_ID,
+      })
+
+      const footer = [...finalMessages].reverse().find((message) => {
+        return message.author.id === ctx.discord.botUserId
+          && message.content.startsWith('*')
+          && message.content.includes('⋅')
+      })
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-model-switch-tester)
+        Reply with exactly: model-switcher-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        Model set for this session:
+        **Deterministic Provider** / **deterministic-v3**
+        \`deterministic-provider/deterministic-v3\`
+        _Restarting current request with new model..._
+        _Tip: create [agent .md files](https://github.com/remorses/kimaki/blob/main/docs/model-switching.md) in .opencode/agent/ for one-command model switching_
+        --- from: user (queue-model-switch-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER
+        --- from: assistant (TestBot)
+        ⬥ ok
+        ⬥ starting sleep 100
+        --- from: user (queue-model-switch-tester)
+        Reply with exactly: model-switcher-followup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v3*"
+      `)
+
+      expect(footer).toBeDefined()
+      expect(footer?.content).toContain('deterministic-v3')
+
+      const getClient = await initializeOpencodeForDirectory(
+        ctx.directories.projectDirectory,
+      )
+      if (getClient instanceof Error) {
+        throw getClient
+      }
+      const sessionMessagesResponse = await getClient().session.messages({
+        sessionID: sessionId,
+        directory: ctx.directories.projectDirectory,
+      })
+      const sessionMessages = sessionMessagesResponse.data || []
+      const emptyUserMessagesWithDefaultModel = sessionMessages.filter((message) => {
+        if (message.info.role !== 'user') {
+          return false
+        }
+        const hasNonEmptyTextPart = message.parts.some((part) => {
+          if (part.type !== 'text') {
+            return false
+          }
+          return part.text.trim().length > 0
+        })
+        if (hasNonEmptyTextPart) {
+          return false
+        }
+        return message.info.model.modelID === 'deterministic-v2'
+      })
+      expect(emptyUserMessagesWithDefaultModel.length).toBe(0)
+    },
+    20_000,
+  )
+})

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

@@ -7,6 +7,7 @@ import {
 } from './queue-advanced-e2e-setup.js'
 import {
   waitForBotMessageContaining,
+  waitForBotReplyAfterUserMessage,
   waitForFooterMessage,
 } from './test-utils.js'
 import { pendingPermissions } from './session-handler/thread-session-runtime.js'
@@ -140,4 +141,95 @@ describe('queue advanced: typing around permissions', () => {
     },
     20_000,
   )
+
+  test(
+    'manual thread message dismisses pending permission and sends the new prompt',
+    async () => {
+      const initialPrompt = 'PERMISSION_TYPING_MARKER dismiss-flow'
+
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: initialPrompt,
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === initialPrompt
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await waitForPendingPermission({
+        threadId: thread.id,
+        timeoutMs: 4_000,
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'Permission Required',
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: post-permission-user-message',
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'Permission dismissed - user sent a new message.',
+        timeout: 4_000,
+      })
+
+      await waitForBotReplyAfterUserMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        userMessageIncludes: 'post-permission-user-message',
+        timeout: 4_000,
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        afterUserMessageIncludes: 'post-permission-user-message',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      const normalizedTimeline = timeline.replace(
+        '⬥ requesting external read permission\n',
+        '',
+      )
+      expect(normalizedTimeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-permission-tester)
+        PERMISSION_TYPING_MARKER dismiss-flow
+        --- from: assistant (TestBot)
+        ⚠️ **Permission Required**
+        **Type:** \`external_directory\`
+        Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)
+        **Pattern:** \`/Users/morse/*\`
+        _Permission dismissed - user sent a new message._
+        --- from: user (queue-permission-tester)
+        Reply with exactly: post-permission-user-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
 })

package/src/runtime-lifecycle.e2e.test.ts

@@ -7,7 +7,7 @@
 // Poll timeouts: 4s max, 100ms interval.
 
 import fs from 'node:fs'
-import net from 'node:net'
+
 import path from 'node:path'
 import url from 'node:url'
 import { describe, beforeAll, afterAll, test, expect } from 'vitest'
@@ -36,6 +36,7 @@ import {
   stopOpencodeServer,
 } from './opencode.js'
 import {
+  chooseLockPort,
   cleanupTestSessions,
   waitForBotMessageContaining,
   waitForBotReplyAfterUserMessage,
@@ -54,23 +55,7 @@ function createRunDirectories() {
   return { root, dataDir, projectDirectory }
 }
 
-function chooseLockPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer()
-    server.listen(0, () => {
-      const address = server.address()
-      if (!address || typeof address === 'string') {
-        server.close()
-        reject(new Error('Failed to resolve lock port'))
-        return
-      }
-      const port = address.port
-      server.close(() => {
-        resolve(port)
-      })
-    })
-  })
-}
+
 
 function createDiscordJsClient({ restUrl }: { restUrl: string }) {
   return new Client({
@@ -156,7 +141,7 @@ describe('runtime lifecycle', () => {
   beforeAll(async () => {
     testStartTime = Date.now()
     directories = createRunDirectories()
-    const lockPort = await chooseLockPort()
+    const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID })
 
     process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
     setDataDir(directories.dataDir)

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

@@ -411,7 +411,7 @@ describe('real-session-task-user-interruption', () => {
   const firstAssistantId = 'msg_cb9b0ba96001SpPjgzxWPmRuW9'
   const secondAssistantId = 'msg_cb9b1ae5c001E5G3Ql6aXNpst2'
 
-  test('tool-call handoff assistant is not terminal but the resumed reply is', () => {
+  test('tool-call handoff assistant is not a natural completion but the resumed reply is', () => {
     const firstAssistant = getAssistantMessageById({
       events,
       sessionId,
@@ -422,6 +422,8 @@ describe('real-session-task-user-interruption', () => {
       sessionId,
       messageId: secondAssistantId,
     })
+    // The first message finished with tool-calls — not a natural completion
+    // (footer is deferred to session.idle). The second message IS natural.
     expect(isAssistantMessageNaturalCompletion({ message: firstAssistant })).toBe(false)
     expect(isAssistantMessageNaturalCompletion({ message: secondAssistant })).toBe(true)
   })
@@ -558,7 +560,7 @@ describe('real-session-action-buttons', () => {
   const toolCallAssistantId = 'msg_cb9b55c3b001hXC9qxjVxLMypM'
   const finalAssistantId = 'msg_cb9b5ddd1001FALqKNM6xW98u6'
 
-  test('tool-call handoff assistant is not terminal but final reply is', () => {
+  test('tool-call handoff assistant is not a natural completion but final reply is', () => {
     const toolCallAssistant = getAssistantMessageById({
       events,
       sessionId,
@@ -569,6 +571,8 @@ describe('real-session-action-buttons', () => {
       sessionId,
       messageId: finalAssistantId,
     })
+    // The tool-call message has finish="tool-calls" — not a natural completion
+    // (footer is deferred to session.idle). The final text message IS natural.
     expect(isAssistantMessageNaturalCompletion({ message: toolCallAssistant })).toBe(false)
     expect(isAssistantMessageNaturalCompletion({ message: finalAssistant })).toBe(true)
   })

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

@@ -116,6 +116,11 @@ export function isAssistantMessageNaturalCompletion({
   if (message.error) {
     return false
   }
+  // finish="tool-calls" means the model's last step was tool execution.
+  // Mid-turn tool-call steps don't get footers — the footer comes from the
+  // final text response (finish="stop") that follows. If the turn ends with
+  // only tool-calls and no text follow-up, no footer is emitted. This is
+  // acceptable since models almost always follow up with text after tools.
   return message.finish !== 'tool-calls'
 }
 

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

@@ -123,6 +123,7 @@ import {
   matchThinkingValue,
 } from '../thinking-utils.js'
 import { execAsync } from '../worktrees.js'
+
 import { notifyError } from '../sentry.js'
 import { createDebouncedProcessFlush } from '../debounced-process-flush.js'
 import { cancelHtmlActionsForThread } from '../html-actions.js'
@@ -173,7 +174,10 @@ export function getOrCreateRuntime(
     // Reconcile sdkDirectory: worktree threads transition from pending
     // (projectDirectory) to ready (worktree path) after runtime creation.
     if (existing.sdkDirectory !== opts.sdkDirectory) {
-      existing.sdkDirectory = opts.sdkDirectory
+      existing.handleDirectoryChanged({
+        oldDirectory: existing.sdkDirectory,
+        newDirectory: opts.sdkDirectory,
+      })
     }
     return existing
   }
@@ -833,6 +837,44 @@ export class ThreadSessionRuntime {
     cleanupPendingUiForThread(this.thread.id)
   }
 
+  // Called when sdkDirectory changes (e.g. worktree becomes ready after
+  // /new-worktree in an existing thread). The event listener was subscribed
+  // to the old directory's Instance in opencode — events from the new
+  // directory's Instance won't reach it. We must reconnect the listener
+  // and clear the old session so ensureSession creates a fresh one under
+  // the new Instance.
+  handleDirectoryChanged({
+    oldDirectory,
+    newDirectory,
+  }: {
+    oldDirectory: string
+    newDirectory: string
+  }): void {
+    logger.log(
+      `[LISTENER] sdkDirectory changed for thread ${this.threadId}: ${oldDirectory} → ${newDirectory}`,
+    )
+    this.sdkDirectory = newDirectory
+
+    // Clear cached session — it was created under the old directory's
+    // opencode Instance and can't be reused from the new one.
+    threadState.updateThread(this.threadId, (t) => ({
+      ...t,
+      sessionId: undefined,
+    }))
+
+    // Restart event listener to subscribe under the new directory.
+    const currentController = this.state?.listenerController
+    if (currentController) {
+      currentController.abort(new Error('sdkDirectory changed'))
+      threadState.updateThread(this.threadId, (t) => ({
+        ...t,
+        listenerController: new AbortController(),
+      }))
+      this.listenerLoopRunning = false
+      void this.startEventListener()
+    }
+  }
+
   handleSharedServerStarted({
     port,
   }: {
@@ -2033,6 +2075,7 @@ export class ThreadSessionRuntime {
         `[SESSION IDLE] session became idle sessionId=${sessionId} drainQueue=${shouldDrainQueuedMessages} ${this.formatRunStateForLog()}`,
       )
       await this.persistEventBufferDebounced.flush()
+
       if (!shouldDrainQueuedMessages) {
         return
       }
@@ -3492,7 +3535,7 @@ export class ThreadSessionRuntime {
 
     const client = getOpencodeClient(this.projectDirectory)
 
-    // Run git branch, token fetch, and provider list in parallel
+    // Run git branch and token fetch in parallel (fast, no external CLI)
     const [branchResult, contextResult] = await Promise.all([
       errore.tryAsync(() => {
         return execAsync('git symbolic-ref --short HEAD', {