kimaki 0.26.0 → 0.28.0

package/src/voice-handler.ts

@@ -41,7 +41,7 @@ import {
 } from './discord-utils.js'
 import { requestAudioApiKey } from './commands/gemini-apikey.js'
 import { transcribeAudio, type TranscriptionResult } from './voice.js'
-import { DiscordOperationError, FetchError } from './errors.js'
+import { DiscordOperationError, FetchError, EmptyTranscriptionError, TranscriptionError } from './errors.js'
 import { store } from './store.js'
 import {
   getVoiceAttachmentMatchReason,
@@ -486,6 +486,7 @@ type ProcessVoiceAttachmentArgs = {
   lastSessionContext?: string
   /** Available agents for voice-based agent selection. Passed to the transcription prompt as enum values. */
   agents?: Array<{ name: string; description?: string }>
+  canForkSession?: boolean
 }
 
 // Per-thread serialization is handled by ThreadSessionRuntime.enqueueIncoming()
@@ -499,7 +500,8 @@ export async function processVoiceAttachment({
   currentSessionContext,
   lastSessionContext,
   agents,
-}: ProcessVoiceAttachmentArgs): Promise<TranscriptionResult | null> {
+  canForkSession = false,
+}: ProcessVoiceAttachmentArgs): Promise<TranscriptionResult | TranscriptionError | EmptyTranscriptionError | null> {
   const audioAttachment = Array.from(message.attachments.values()).find(
     (attachment) => isVoiceAttachment(attachment),
   )
@@ -544,6 +546,11 @@ export async function processVoiceAttachment({
       transcription: deterministicConfig.transcription,
       queueMessage: deterministicConfig.queueMessage,
       agent: deterministicConfig.agent,
+      sessionAction: deterministicConfig.sessionAction,
+    }
+    if (!result.transcription.trim()) {
+      await sendThreadMessage(thread, 'No request was transcribed. Record another voice message with the task to send.')
+      return new EmptyTranscriptionError()
     }
     voiceLogger.log(
       `[DETERMINISTIC] Returning canned transcription: "${result.transcription}"${result.queueMessage ? ' [QUEUE]' : ''}`,
@@ -566,6 +573,10 @@ export async function processVoiceAttachment({
       thread,
       `📝 **Transcribed message:** ${escapeDiscordFormatting(result.transcription)}`,
     )
+    if (result.sessionAction === 'btw' && !canForkSession) {
+      await sendThreadMessage(thread, 'A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request.')
+      return new TranscriptionError({ reason: 'Contextual routing is unavailable without a source session' })
+    }
     return result
   }
 
@@ -627,7 +638,7 @@ export async function processVoiceAttachment({
   // No user-configured key: gateway-mode installs get one free transcription
   // via the kimaki.dev Whisper fallback before we bother the user with the
   // "add API key" dialog. This fallback has no tool-calling, so it can't
-  // detect queueMessage/agent hints spoken in the voice message the way the
+  // detect queueMessage/sessionAction/agent hints spoken in the voice message the way the
   // OpenAI/Gemini path can.
   let gatewayTranscription: string | undefined
   if (!transcriptionApiKey) {
@@ -677,14 +688,18 @@ export async function processVoiceAttachment({
         currentSessionContext,
         lastSessionContext,
         agents,
+        canForkSession,
       })
 
   if (transcription instanceof Error) {
+    if (transcription instanceof EmptyTranscriptionError) {
+      await sendThreadMessage(thread, 'No request was transcribed. Record another voice message with the task to send.')
+      return transcription
+    }
     const errMsg = errore.matchError(transcription, {
       ApiKeyMissingError: (e) => e.message,
       InvalidAudioFormatError: (e) => e.message,
       TranscriptionError: (e) => e.message,
-      EmptyTranscriptionError: (e) => e.message,
       NoResponseContentError: (e) => e.message,
       NoToolResponseError: (e) => e.message,
       Error: (e) => e.message,
@@ -728,6 +743,10 @@ export async function processVoiceAttachment({
     thread,
     `📝 **Transcribed message:** ${escapeDiscordFormatting(text)}`,
   )
+  if (transcription.sessionAction === 'btw' && !canForkSession) {
+    await sendThreadMessage(thread, 'A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request.')
+    return new TranscriptionError({ reason: 'Contextual routing is unavailable without a source session' })
+  }
   if (agent) {
     await sendThreadMessage(thread, `Detected agent: ${agent}`)
   }

package/src/voice-message.e2e.test.ts

@@ -28,6 +28,10 @@ import {
   closeDatabase,
   setChannelDirectory,
   setChannelVerbosity,
+  getThreadSession,
+  createPendingWorkspace,
+  setWorkspaceReady,
+  getThreadWorktreeOrWorkspace,
 } from './database.js'
 import { startHranaServer, stopHranaServer } from './hrana-server.js'
 import { initializeOpencodeForDirectory, getOpencodeClient, stopOpencodeServer } from './opencode.js'
@@ -429,6 +433,122 @@ e2eTest('voice message handling', () => {
 
   // ── Test 1: Voice message in a channel creates thread + session ──
 
+  // Vitest disallows inline snapshots in test.each; register separate tests instead.
+  for (const sessionAction of ['btw', 'new-session'] as const) {
+    test(
+      `voice ${sessionAction} routing creates a separate thread with the correct history`,
+      async () => {
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID)
+          .sendMessage({ content: `Source history for voice ${sessionAction}` })
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+          timeout: 4_000,
+          predicate: (candidate) => Boolean(candidate.name?.includes(`Source history for voice ${sessionAction}`)),
+        })
+        await waitForFooterMessage({ discord, threadId: thread.id, timeout: 4_000 })
+        const sourceSessionId = await getThreadSession(thread.id)
+        await createPendingWorkspace({
+          threadId: thread.id,
+          workspaceType: 'worktree',
+          workspaceName: 'voice-workspace',
+          projectDirectory: directories.projectDirectory,
+        })
+        await setWorkspaceReady({
+          threadId: thread.id,
+          workspaceId: 'voice-workspace-id',
+          workspaceDirectory: directories.projectDirectory,
+        })
+        const prompt = `Explain voice routing ${sessionAction}`
+        setDeterministicTranscription({ transcription: prompt, queueMessage: false, sessionAction })
+        await discord.thread(thread.id).user(TEST_USER_ID).sendVoiceMessage()
+        const confirmation = sessionAction === 'btw' ? 'Session forked!' : 'Created new session in'
+        const routingMessages = await waitForBotMessageContaining({
+          discord,
+          threadId: thread.id,
+          text: confirmation,
+          timeout: 4_000,
+        })
+        // OpenCode can rename the destination before discovery; follow its confirmed ID.
+        const targetId = routingMessages.find((message) => message.content.includes(confirmation))
+          ?.content.match(/<#(\d+)>/)?.[1]
+        if (!targetId) throw new Error('Expected destination thread link')
+        const target = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+          timeout: 4_000,
+          predicate: (candidate) => candidate.id === targetId,
+        })
+        await waitForFooterMessage({ discord, threadId: target.id, timeout: 4_000 })
+        const th = discord.thread(target.id)
+        const transcript = {
+          source: (await discord.thread(thread.id).text()).replaceAll(target.id, 'TARGET_THREAD'),
+          target: (await th.text()).replaceAll(thread.id, 'SOURCE_THREAD'),
+        }
+        if (sessionAction === 'btw') {
+          expect(transcript).toMatchInlineSnapshot(`
+            {
+              "source": "--- from: user (voice-tester)
+            Source history for voice btw
+            --- from: assistant (TestBot)
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
+            --- from: user (voice-tester)
+            [attachment: voice-message.ogg]
+            --- from: assistant (TestBot)
+            🎤 Transcribing voice message...
+            📝 **Transcribed message:** Explain voice routing btw
+            Session forked! Continue in <#TARGET_THREAD>",
+              "target": "--- from: assistant (TestBot)
+            Reusing context from <#SOURCE_THREAD> to answer prompt...
+            Explain voice routing btw
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>",
+            }
+          `)
+        } else {
+          expect(transcript).toMatchInlineSnapshot(`
+            {
+              "source": "--- from: user (voice-tester)
+            Source history for voice new-session
+            --- from: assistant (TestBot)
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
+            --- from: user (voice-tester)
+            [attachment: voice-message.ogg]
+            --- from: assistant (TestBot)
+            🎤 Transcribing voice message...
+            📝 **Transcribed message:** Explain voice routing new-session
+            Created new session in <#TARGET_THREAD>",
+              "target": "--- from: assistant (TestBot)
+            **Starting OpenCode session**
+            Explain voice routing new-session
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>",
+            }
+          `)
+        }
+        const targetSessionId = await getThreadSession(target.id)
+        expect(targetSessionId).toBeTruthy()
+        expect(targetSessionId).not.toBe(sourceSessionId)
+        expect(await getThreadWorktreeOrWorkspace(target.id)).toMatchObject({
+          status: 'ready',
+          workspace_type: 'worktree',
+          workspace_name: 'voice-workspace',
+          workspace_id: 'voice-workspace-id',
+          workspace_directory: directories.projectDirectory,
+        })
+        const client = getOpencodeClientForTest(directories.projectDirectory)
+        const targetMessages = await client.session.messages({ sessionID: targetSessionId! })
+        const targetTexts = getUserTexts(targetMessages.data ?? []).join('\n')
+        expect(targetTexts).toContain(prompt)
+        expect(targetTexts).toContain(`Voice message transcription from Discord user:\n${prompt}`)
+        expect(targetTexts.includes(`Source history for voice ${sessionAction}`)).toBe(sessionAction === 'btw')
+        const sourceMessages = await client.session.messages({ sessionID: sourceSessionId! })
+        expect(getUserTexts(sourceMessages.data ?? []).join('\n')).not.toContain(prompt)
+      },
+    )
+  }
+
   test(
     'voice message in channel creates thread and starts session',
     async () => {
@@ -503,9 +623,9 @@ e2eTest('voice message handling', () => {
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Fix the login bug in auth.ts
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
       expect(finalState.sessionId).toBeDefined()
 
@@ -607,9 +727,9 @@ e2eTest('voice message handling', () => {
         Voice transcription requires an API key (OpenAI or Gemini). Set one to enable voice message transcription.
         Gemini API key saved. Retrying the original voice message.
         📝 **Transcribed message:** Resume the original voice note
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
 
       const finalState = getThreadState(thread.id)
@@ -685,9 +805,9 @@ e2eTest('voice message handling', () => {
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Investigate the missing content type path
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
 
       const messages = await waitForSessionMessages({
@@ -794,16 +914,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER initial setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Add error handling to the parser
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
       expect(finalState?.sessionId).toBeDefined()
       if (!finalState?.sessionId) {
@@ -1053,19 +1173,19 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         SLOW_RESPONSE_MARKER start queued task
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Queue this task for later
         Queued at position 1. Edit or delete your message to update the queue
-        ⬥ slow-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > slow-response-done
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2*
         » **voice-tester:** Voice message transcription from Discord user:
         Queue this task for later
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
       expect(finalState.queueItems.length).toBe(0)
 
@@ -1181,16 +1301,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER quick task
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Delayed transcription result
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
       expect(finalState.sessionId).toBeDefined()
       expect(finalState.queueItems.length).toBe(0)
@@ -1319,16 +1439,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER fast before queued voice
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Queued voice after idle
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `)
       expect(finalState.sessionId).toBeDefined()
       expect(finalState.queueItems.length).toBe(0)

package/src/voice-routing-input.e2e.test.ts

@@ -0,0 +1,203 @@
+// Cover long routed prompts and rejected voice routes without an existing session.
+import { afterEach, describe, expect, test } from 'vitest'
+import { ChannelType } from 'discord.js'
+import { setupQueueAdvancedSuite, TEST_USER_ID } from './queue-advanced-e2e-setup.js'
+import { waitForBotMessageContaining, waitForFooterMessage } from './test-utils.js'
+import { getThreadSession } from './database.js'
+import { getOpencodeClient } from './opencode.js'
+import { store } from './store.js'
+
+const TEXT_CHANNEL_ID = '200000000000001084'
+
+describe('voice routing input boundaries', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'voice-routing-input',
+    dirName: 'voice-routing-input',
+    username: 'voice-input-tester',
+  })
+
+  afterEach(() => {
+    store.setState({ test: { deterministicTranscription: null } })
+  })
+
+  test('fresh voice route splits display and preserves the full model prompt', async () => {
+    const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID)
+    if (channel?.type !== ChannelType.GuildText) throw new Error('Expected text channel')
+    const source = await channel.threads.create({ name: 'Long voice source' })
+    const prompt = `Long voice request ${'Z'.repeat(2100)} END_OF_REQUEST`
+    const caption = 'Keep the existing public API unchanged.'
+    store.setState({
+      test: {
+        deterministicTranscription: {
+          transcription: prompt,
+          queueMessage: false,
+          sessionAction: 'new-session',
+        },
+      },
+    })
+    await ctx.discord.thread(source.id).user(TEST_USER_ID).sendVoiceMessage({ content: caption })
+    const routingMessages = await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: source.id,
+      text: 'Created new session in',
+      timeout: 4_000,
+    })
+    const targetId = routingMessages.find((message) => message.content.includes('Created new session in'))
+      ?.content.match(/<#(\d+)>/)?.[1]
+    if (!targetId) throw new Error('Expected destination thread link')
+    const target = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+      timeout: 4_000,
+      predicate: (thread) => thread.id === targetId,
+    })
+    await waitForFooterMessage({ discord: ctx.discord, threadId: target.id, timeout: 4_000 })
+    expect((await ctx.discord.channel(TEXT_CHANNEL_ID).text()).replace(/Z+/g, '[DETAILS]'))
+      .toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        **Starting OpenCode session**
+        Keep the existing public API unchanged.
+
+        "
+      `)
+    expect((await ctx.discord.thread(target.id).text()).replace(/Z+/g, '[DETAILS]'))
+      .toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        **Starting OpenCode session**
+        Keep the existing public API unchanged.
+
+
+        Long voice request [DETAILS]
+        [DETAILS] END_OF_REQUEST
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+      `)
+    const channelMessages = await ctx.discord.channel(TEXT_CHANNEL_ID).getMessages()
+    expect(channelMessages).toHaveLength(1)
+    expect(channelMessages.every((message) => message.content.length <= 2000)).toBe(true)
+    const threadText = await ctx.discord.thread(target.id).text()
+    expect(threadText).toContain(caption)
+    expect(threadText.replace(/\s/g, '')).toContain(prompt.replace(/\s/g, ''))
+    expect(
+      threadText.match(/Z/g),
+    ).toHaveLength(2100)
+    const sessionId = await getThreadSession(target.id)
+    if (!sessionId) throw new Error('Expected target session')
+    const client = getOpencodeClient(ctx.directories.projectDirectory)
+    if (!client) throw new Error('Expected OpenCode client')
+    const messages = await client.session.messages({ sessionID: sessionId })
+    const userTexts = messages.data
+      ?.filter((message) => message.info.role === 'user')
+      .flatMap((message) =>
+        message.parts.flatMap((part) => (part.type === 'text' ? [part.text] : [])),
+      )
+    expect(userTexts?.join('\n')).toContain(
+      `Voice message transcription from Discord user:\n${prompt}`,
+    )
+    expect(userTexts?.join('\n')).toContain(caption)
+    expect(await getThreadSession(source.id)).toBeFalsy()
+  })
+
+  test('unsupported contextual route keeps the transcript and never dispatches raw text', async () => {
+    const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID)
+    if (channel?.type !== ChannelType.GuildText) throw new Error('Expected text channel')
+    const source = await channel.threads.create({ name: 'Unsupported voice source' })
+    const th = ctx.discord.thread(source.id)
+    store.setState({
+      test: {
+        deterministicTranscription: {
+          transcription: 'Explain the parser in a contextual side chat',
+          queueMessage: false,
+          sessionAction: 'btw',
+        },
+      },
+    })
+    await th.user(TEST_USER_ID).sendVoiceMessage({ content: 'Do not dispatch this raw text' })
+    await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: source.id,
+      text: 'Nothing was sent to the agent',
+      timeout: 4_000,
+    })
+    expect(await th.text()).toMatchInlineSnapshot(`
+      "--- from: user (voice-input-tester)
+      Do not dispatch this raw text
+      [attachment: voice-message.ogg]
+      --- from: assistant (TestBot)
+      🎤 Transcribing voice message...
+      📝 **Transcribed message:** Explain the parser in a contextual side chat
+      A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request."
+    `)
+    for (let index = 0; index < 10; index++) {
+      await new Promise((resolve) => setTimeout(resolve, 20))
+      expect(await getThreadSession(source.id)).toBeFalsy()
+    }
+  })
+
+  test('routing-only audio does not start a junk turn', async () => {
+    const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID)
+    if (channel?.type !== ChannelType.GuildText) throw new Error('Expected text channel')
+    const source = await channel.threads.create({ name: 'Empty voice source' })
+    const th = ctx.discord.thread(source.id)
+    store.setState({
+      test: {
+        deterministicTranscription: {
+          transcription: '',
+          queueMessage: false,
+          sessionAction: 'new-session',
+        },
+      },
+    })
+    await th.user(TEST_USER_ID).sendVoiceMessage({ content: 'Create a new chat' })
+    await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: source.id,
+      text: 'No request was transcribed',
+      timeout: 4_000,
+    })
+    expect(await th.text()).toMatchInlineSnapshot(`
+      "--- from: user (voice-input-tester)
+      Create a new chat
+      [attachment: voice-message.ogg]
+      --- from: assistant (TestBot)
+      🎤 Transcribing voice message...
+      No request was transcribed. Record another voice message with the task to send."
+    `)
+    for (let index = 0; index < 10; index++) {
+      await new Promise((resolve) => setTimeout(resolve, 20))
+      expect(await getThreadSession(source.id)).toBeFalsy()
+    }
+  })
+
+  test('/new-session confirms the destination and sends the prompt', async () => {
+    const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID)
+    if (channel?.type !== ChannelType.GuildText) throw new Error('Expected text channel')
+    const source = await channel.threads.create({ name: 'Slash source' })
+    const th = ctx.discord.thread(source.id)
+    const interaction = await th.user(TEST_USER_ID).runSlashCommand({
+      name: 'new-session',
+      options: [{ name: 'prompt', type: 3, value: 'Slash fresh request' }],
+    })
+    await th.waitForInteractionAck({ interactionId: interaction.id, timeout: 4_000 })
+    const target = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+      timeout: 4_000,
+      predicate: (thread) => thread.name === 'Slash fresh request',
+    })
+    await waitForFooterMessage({ discord: ctx.discord, threadId: target.id, timeout: 4_000 })
+    expect(
+      (await th.text({ showInteractions: true })).replaceAll(target.id, 'TARGET_THREAD'),
+    ).toMatchInlineSnapshot(`
+      "[user interaction]
+      --- from: assistant (TestBot)
+      Created new session in <#TARGET_THREAD>"
+    `)
+    expect(await ctx.discord.thread(target.id).text()).toMatchInlineSnapshot(`
+      "--- from: assistant (TestBot)
+      **Starting OpenCode session**
+      Slash fresh request
+      > *using deterministic-provider/deterministic-v2*
+      > ok
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+    `)
+  })
+})