kimaki 0.4.44 → 0.4.46

package/src/session-handler.ts

@@ -2,7 +2,7 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 
-import type { Part, PermissionRequest } from '@opencode-ai/sdk/v2'
+import type { Part, PermissionRequest, QuestionRequest } from '@opencode-ai/sdk/v2'
 import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
@@ -14,6 +14,7 @@ import {
   getChannelAgent,
   setSessionAgent,
   getThreadWorktree,
+  getChannelVerbosity,
 } from './database.js'
 import {
   initializeOpencodeForDirectory,
@@ -30,7 +31,11 @@ import {
   cancelPendingQuestion,
   pendingQuestionContexts,
 } from './commands/ask-question.js'
-import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js'
+import {
+  showPermissionDropdown,
+  cleanupPermissionContext,
+  addPermissionRequestToContext,
+} from './commands/permissions.js'
 import * as errore from 'errore'
 
 const sessionLogger = createLogger('SESSION')
@@ -44,9 +49,31 @@ export const abortControllers = new Map<string, AbortController>()
 // to avoid duplicates and properly clean up on auto-reject
 export const pendingPermissions = new Map<
   string, // threadId
-  Map<string, { permission: PermissionRequest; messageId: string; directory: string; contextHash: string }> // permissionId -> data
+  Map<
+    string,
+    {
+      permission: PermissionRequest
+      messageId: string
+      directory: string
+      contextHash: string
+      dedupeKey: string
+    }
+  > // permissionId -> data
 >()
 
+function buildPermissionDedupeKey({
+  permission,
+  directory,
+}: {
+  permission: PermissionRequest
+  directory: string
+}): string {
+  const normalizedPatterns = [...permission.patterns].sort((a, b) => {
+    return a.localeCompare(b)
+  })
+  return `${directory}::${permission.permission}::${normalizedPatterns.join('|')}`
+}
+
 export type QueuedMessage = {
   prompt: string
   userId: string
@@ -59,6 +86,8 @@ export type QueuedMessage = {
 // Key is threadId, value is array of queued messages
 export const messageQueue = new Map<string, QueuedMessage[]>()
 
+const activeEventHandlers = new Map<string, Promise<void>>()
+
 export function addToQueue({
   threadId,
   message,
@@ -113,10 +142,11 @@ export async function abortAndRetrySession({
     sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message)
     return false
   }
-  try {
-    await getClient().session.abort({ path: { id: sessionId } })
-  } catch (e) {
-    sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, e)
+  const abortResult = await errore.tryAsync(() => {
+    return getClient().session.abort({ path: { id: sessionId } })
+  })
+  if (abortResult instanceof Error) {
+    sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, abortResult)
   }
 
   // Small delay to let the abort propagate
@@ -146,16 +176,25 @@ export async function abortAndRetrySession({
 
   // Use setImmediate to avoid blocking
   setImmediate(() => {
-    handleOpencodeSession({
-      prompt,
-      thread,
-      projectDirectory,
-      images,
-    }).catch(async (e) => {
-      sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, e)
-      const errorMsg = e instanceof Error ? e.message : String(e)
-      await sendThreadMessage(thread, `✗ Failed to retry with new model: ${errorMsg.slice(0, 200)}`)
-    })
+    void errore
+      .tryAsync(async () => {
+        return handleOpencodeSession({
+          prompt,
+          thread,
+          projectDirectory,
+          images,
+        })
+      })
+      .then(async (result) => {
+        if (!(result instanceof Error)) {
+          return
+        }
+        sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, result)
+        await sendThreadMessage(
+          thread,
+          `✗ Failed to retry with new model: ${result.message.slice(0, 200)}`,
+        )
+      })
   })
 
   return true
@@ -191,6 +230,18 @@ export async function handleOpencodeSession({
   const directory = projectDirectory || process.cwd()
   sessionLogger.log(`Using directory: ${directory}`)
 
+  // Get worktree info early so we can use the correct directory for events and prompts
+  const worktreeInfo = getThreadWorktree(thread.id)
+  const worktreeDirectory =
+    worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+      ? worktreeInfo.worktree_directory
+      : undefined
+  // Use worktree directory for SDK calls if available, otherwise project directory
+  const sdkDirectory = worktreeDirectory || directory
+  if (worktreeDirectory) {
+    sessionLogger.log(`Using worktree directory for SDK calls: ${worktreeDirectory}`)
+  }
+
   const getClient = await initializeOpencodeForDirectory(directory)
   if (getClient instanceof Error) {
     await sendThreadMessage(thread, `✗ ${getClient.message}`)
@@ -208,14 +259,17 @@ export async function handleOpencodeSession({
 
   if (sessionId) {
     sessionLogger.log(`Attempting to reuse existing session ${sessionId}`)
-    try {
-      const sessionResponse = await getClient().session.get({
+    const sessionResponse = await errore.tryAsync(() => {
+      return getClient().session.get({
         path: { id: sessionId },
+        query: { directory: sdkDirectory },
       })
+    })
+    if (sessionResponse instanceof Error) {
+      voiceLogger.log(`[SESSION] Session ${sessionId} not found, will create new one`)
+    } else {
       session = sessionResponse.data
       sessionLogger.log(`Successfully reused session ${sessionId}`)
-    } catch (error) {
-      voiceLogger.log(`[SESSION] Session ${sessionId} not found, will create new one`)
     }
   }
 
@@ -224,6 +278,7 @@ export async function handleOpencodeSession({
     voiceLogger.log(`[SESSION] Creating new session with title: "${sessionTitle}"`)
     const sessionResponse = await getClient().session.create({
       body: { title: sessionTitle },
+      query: { directory: sdkDirectory },
     })
     session = sessionResponse.data
     sessionLogger.log(`Created new session ${session?.id}`)
@@ -248,6 +303,15 @@ export async function handleOpencodeSession({
   if (existingController) {
     voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`)
     existingController.abort(new Error('New request started'))
+    const abortResult = await errore.tryAsync(() => {
+      return getClient().session.abort({
+        path: { id: session.id },
+        query: { directory: sdkDirectory },
+      })
+    })
+    if (abortResult instanceof Error) {
+      sessionLogger.log(`[ABORT] Server abort failed (may be already done):`, abortResult)
+    }
   }
 
   // Auto-reject ALL pending permissions for this thread
@@ -256,20 +320,25 @@ export async function handleOpencodeSession({
     const clientV2 = getOpencodeClientV2(directory)
     let rejectedCount = 0
     for (const [permId, pendingPerm] of threadPermissions) {
-      try {
-        sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`)
-        if (clientV2) {
-          await clientV2.permission.reply({
-            requestID: permId,
-            reply: 'reject',
-          })
-        }
+      sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`)
+      if (!clientV2) {
+        sessionLogger.log(`[PERMISSION] OpenCode v2 client unavailable for permission ${permId}`)
         cleanupPermissionContext(pendingPerm.contextHash)
         rejectedCount++
-      } catch (e) {
-        sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, e)
-        cleanupPermissionContext(pendingPerm.contextHash)
+        continue
+      }
+      const rejectResult = await errore.tryAsync(() => {
+        return clientV2.permission.reply({
+          requestID: permId,
+          reply: 'reject',
+        })
+      })
+      if (rejectResult instanceof Error) {
+        sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, rejectResult)
+      } else {
+        rejectedCount++
       }
+      cleanupPermissionContext(pendingPerm.contextHash)
     }
     pendingPermissions.delete(thread.id)
     if (rejectedCount > 0) {
@@ -305,13 +374,24 @@ export async function handleOpencodeSession({
     return
   }
 
+  const previousHandler = activeEventHandlers.get(thread.id)
+  if (previousHandler) {
+    sessionLogger.log(`[EVENT] Waiting for previous handler to finish`)
+    await Promise.race([
+      previousHandler,
+      new Promise((resolve) => {
+        setTimeout(resolve, 1000)
+      }),
+    ])
+  }
+
   // Use v2 client for event subscription (has proper types for question.asked events)
   const clientV2 = getOpencodeClientV2(directory)
   if (!clientV2) {
     throw new Error(`OpenCode v2 client not found for directory: ${directory}`)
   }
   const eventsResult = await clientV2.event.subscribe(
-    { directory },
+    { directory: sdkDirectory },
     { signal: abortController.signal },
   )
 
@@ -331,7 +411,7 @@ export async function handleOpencodeSession({
     ).map((row) => row.part_id),
   )
 
-  let currentParts: Part[] = []
+  const partBuffer = new Map<string, Map<string, Part>>()
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
   let usedProviderID: string | undefined
@@ -339,6 +419,8 @@ export async function handleOpencodeSession({
   let tokensUsedInSession = 0
   let lastDisplayedContextPercentage = 0
   let modelContextLimit: number | undefined
+  let assistantMessageId: string | undefined
+  let handlerPromise: Promise<void> | null = null
 
   let typingInterval: NodeJS.Timeout | null = null
 
@@ -352,13 +434,17 @@ export async function handleOpencodeSession({
       typingInterval = null
     }
 
-    thread.sendTyping().catch((e) => {
-      discordLogger.log(`Failed to send initial typing: ${e}`)
+    void errore.tryAsync(() => thread.sendTyping()).then((result) => {
+      if (result instanceof Error) {
+        discordLogger.log(`Failed to send initial typing: ${result}`)
+      }
     })
 
     typingInterval = setInterval(() => {
-      thread.sendTyping().catch((e) => {
-        discordLogger.log(`Failed to send periodic typing: ${e}`)
+      void errore.tryAsync(() => thread.sendTyping()).then((result) => {
+        if (result instanceof Error) {
+          discordLogger.log(`Failed to send periodic typing: ${result}`)
+        }
       })
     }, 8000)
 
@@ -383,7 +469,16 @@ export async function handleOpencodeSession({
     }
   }
 
+  // Get verbosity setting for this channel (use parent channel for threads)
+  const verbosityChannelId = channelId || thread.parentId || thread.id
+  const verbosity = getChannelVerbosity(verbosityChannelId)
+
   const sendPartMessage = async (part: Part) => {
+    // In text-only mode, only send text parts (the ⬥ diamond messages)
+    if (verbosity === 'text-only' && part.type !== 'text') {
+      return
+    }
+
     const content = formatPart(part) + '\n\n'
     if (!content.trim() || content.length === 0) {
       // discordLogger.log(`SKIP: Part ${part.id} has no content`)
@@ -394,18 +489,20 @@ export async function handleOpencodeSession({
       return
     }
 
-    try {
-      const firstMessage = await sendThreadMessage(thread, content)
-      sentPartIds.add(part.id)
-
-      getDatabase()
-        .prepare(
-          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-        )
-        .run(part.id, firstMessage.id, thread.id)
-    } catch (error) {
-      discordLogger.error(`ERROR: Failed to send part ${part.id}:`, error)
+    const sendResult = await errore.tryAsync(() => {
+      return sendThreadMessage(thread, content)
+    })
+    if (sendResult instanceof Error) {
+      discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult)
+      return
     }
+    sentPartIds.add(part.id)
+
+    getDatabase()
+      .prepare(
+        'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+      )
+      .run(part.id, sendResult.id, thread.id)
   }
 
   const eventHandler = async () => {
@@ -414,390 +511,548 @@ export async function handleOpencodeSession({
     // Counts spawned tasks per agent type: "explore" → 2
     const agentSpawnCounts: Record<string, number> = {}
 
-    try {
-      let assistantMessageId: string | undefined
+    const storePart = (part: Part) => {
+      const messageParts = partBuffer.get(part.messageID) || new Map<string, Part>()
+      messageParts.set(part.id, part)
+      partBuffer.set(part.messageID, messageParts)
+    }
 
-      for await (const event of events) {
-        if (event.type === 'message.updated') {
-          const msg = event.properties.info
+    const getBufferedParts = (messageID: string) => {
+      return Array.from(partBuffer.get(messageID)?.values() ?? [])
+    }
 
-          // Track assistant message IDs for subtask sessions
-          const subtaskInfo = subtaskSessions.get(msg.sessionID)
-          if (subtaskInfo && msg.role === 'assistant') {
-            subtaskInfo.assistantMessageId = msg.id
-          }
+    const shouldSendPart = ({ part, force }: { part: Part; force: boolean }) => {
+      if (part.type === 'step-start' || part.type === 'step-finish') {
+        return false
+      }
 
-          if (msg.sessionID !== session.id) {
-            continue
-          }
+      if (part.type === 'tool' && part.state.status === 'pending') {
+        return false
+      }
 
-          if (msg.role === 'assistant') {
-            const newTokensTotal =
-              msg.tokens.input +
-              msg.tokens.output +
-              msg.tokens.reasoning +
-              msg.tokens.cache.read +
-              msg.tokens.cache.write
-            if (newTokensTotal > 0) {
-              tokensUsedInSession = newTokensTotal
-            }
+      if (!force && part.type === 'text' && !part.time?.end) {
+        return false
+      }
 
-            assistantMessageId = msg.id
-            usedModel = msg.modelID
-            usedProviderID = msg.providerID
-            usedAgent = msg.mode
-
-            if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
-              if (!modelContextLimit) {
-                try {
-                  const providersResponse = await getClient().provider.list({
-                    query: { directory },
-                  })
-                  const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
-                  const model = provider?.models?.[usedModel]
-                  if (model?.limit?.context) {
-                    modelContextLimit = model.limit.context
-                  }
-                } catch (e) {
-                  sessionLogger.error('Failed to fetch provider info for context limit:', e)
-                }
-              }
+      if (!force && part.type === 'tool' && part.state.status === 'completed') {
+        return false
+      }
 
-              if (modelContextLimit) {
-                const currentPercentage = Math.floor(
-                  (tokensUsedInSession / modelContextLimit) * 100,
-                )
-                const thresholdCrossed = Math.floor(currentPercentage / 10) * 10
-                if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
-                  lastDisplayedContextPercentage = thresholdCrossed
-                  const chunk = `⬦ context usage ${currentPercentage}%`
-                  await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
-                }
-              }
-            }
-          }
-        } else if (event.type === 'message.part.updated') {
-          const part = event.properties.part
+      return true
+    }
 
-          // Check if this is a subtask event (child session we're tracking)
-          const subtaskInfo = subtaskSessions.get(part.sessionID)
-          const isSubtaskEvent = Boolean(subtaskInfo)
+    const flushBufferedParts = async ({
+      messageID,
+      force,
+      skipPartId,
+    }: {
+      messageID: string
+      force: boolean
+      skipPartId?: string
+    }) => {
+      if (!messageID) {
+        return
+      }
+      const parts = getBufferedParts(messageID)
+      for (const part of parts) {
+        if (skipPartId && part.id === skipPartId) {
+          continue
+        }
+        if (!shouldSendPart({ part, force })) {
+          continue
+        }
+        await sendPartMessage(part)
+      }
+    }
 
-          // Accept events from main session OR tracked subtask sessions
-          if (part.sessionID !== session.id && !isSubtaskEvent) {
-            continue
-          }
+    const handleMessageUpdated = async (msg: {
+      id: string
+      sessionID: string
+      role: string
+      modelID?: string
+      providerID?: string
+      mode?: string
+      tokens?: {
+        input: number
+        output: number
+        reasoning: number
+        cache: { read: number; write: number }
+      }
+    }) => {
+      const subtaskInfo = subtaskSessions.get(msg.sessionID)
+      if (subtaskInfo && msg.role === 'assistant') {
+        subtaskInfo.assistantMessageId = msg.id
+      }
 
-          // For subtask events, send them immediately with prefix (don't buffer in currentParts)
-          if (isSubtaskEvent && subtaskInfo) {
-            // Skip parts that aren't useful to show (step-start, step-finish, pending tools)
-            if (part.type === 'step-start' || part.type === 'step-finish') {
-              continue
-            }
-            if (part.type === 'tool' && part.state.status === 'pending') {
-              continue
-            }
-            // Skip text parts - the outer agent will report the task result anyway
-            if (part.type === 'text') {
-              continue
-            }
-            // Only show parts from assistant messages (not user prompts sent to subtask)
-            // Skip if we haven't seen an assistant message yet, or if this part is from a different message
-            if (
-              !subtaskInfo.assistantMessageId ||
-              part.messageID !== subtaskInfo.assistantMessageId
-            ) {
-              continue
-            }
+      if (msg.sessionID !== session.id) {
+        return
+      }
 
-            const content = formatPart(part, subtaskInfo.label)
-            if (content.trim() && !sentPartIds.has(part.id)) {
-              try {
-                const msg = await sendThreadMessage(thread, content + '\n\n')
-                sentPartIds.add(part.id)
-                getDatabase()
-                  .prepare(
-                    'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                  )
-                  .run(part.id, msg.id, thread.id)
-              } catch (error) {
-                discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, error)
-              }
-            }
-            continue
-          }
+      if (msg.role !== 'assistant') {
+        return
+      }
 
-          // Main session events: require matching assistantMessageId
-          if (part.messageID !== assistantMessageId) {
-            continue
-          }
+      if (msg.tokens) {
+        const newTokensTotal =
+          msg.tokens.input +
+          msg.tokens.output +
+          msg.tokens.reasoning +
+          msg.tokens.cache.read +
+          msg.tokens.cache.write
+        if (newTokensTotal > 0) {
+          tokensUsedInSession = newTokensTotal
+        }
+      }
 
-          const existingIndex = currentParts.findIndex((p: Part) => p.id === part.id)
-          if (existingIndex >= 0) {
-            currentParts[existingIndex] = part
-          } else {
-            currentParts.push(part)
-          }
+      assistantMessageId = msg.id
+      usedModel = msg.modelID
+      usedProviderID = msg.providerID
+      usedAgent = msg.mode
 
-          if (part.type === 'step-start') {
-            // Don't start typing if user needs to respond to a question or permission
-            const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
-              (ctx) => ctx.thread.id === thread.id,
-            )
-            const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0
-            if (!hasPendingQuestion && !hasPendingPermission) {
-              stopTyping = startTyping()
-            }
-          }
+      await flushBufferedParts({
+        messageID: assistantMessageId,
+        force: false,
+      })
 
-          if (part.type === 'tool' && part.state.status === 'running') {
-            // Flush any pending text/reasoning parts before showing the tool
-            // This ensures text the LLM generated before the tool call is shown first
-            for (const p of currentParts) {
-              if (p.type !== 'step-start' && p.type !== 'step-finish' && p.id !== part.id) {
-                await sendPartMessage(p)
-              }
-            }
-            await sendPartMessage(part)
-            // Track task tool and register child session when sessionId is available
-            if (part.tool === 'task' && !sentPartIds.has(part.id)) {
-              const description = (part.state.input?.description as string) || ''
-              const agent = (part.state.input?.subagent_type as string) || 'task'
-              const childSessionId = (part.state.metadata?.sessionId as string) || ''
-              if (description && childSessionId) {
-                agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1
-                const label = `${agent}-${agentSpawnCounts[agent]}`
-                subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined })
-                const taskDisplay = `┣ task **${label}** _${description}_`
-                await sendThreadMessage(thread, taskDisplay + '\n\n')
-                sentPartIds.add(part.id)
-              }
-            }
-          }
+      if (tokensUsedInSession === 0 || !usedProviderID || !usedModel) {
+        return
+      }
 
-          // Show token usage for completed tools with large output (>5k tokens)
-          if (part.type === 'tool' && part.state.status === 'completed') {
-            const output = part.state.output || ''
-            const outputTokens = Math.ceil(output.length / 4)
-            const LARGE_OUTPUT_THRESHOLD = 3000
-            if (outputTokens >= LARGE_OUTPUT_THRESHOLD) {
-              const formattedTokens =
-                outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens)
-              const percentageSuffix = (() => {
-                if (!modelContextLimit) {
-                  return ''
-                }
-                const pct = (outputTokens / modelContextLimit) * 100
-                if (pct < 1) {
-                  return ''
-                }
-                return ` (${pct.toFixed(1)}%)`
-              })()
-              const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`
-              await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
-            }
+      if (!modelContextLimit) {
+        const providersResponse = await errore.tryAsync(() => {
+          return getClient().provider.list({
+            query: { directory: sdkDirectory },
+          })
+        })
+        if (providersResponse instanceof Error) {
+          sessionLogger.error('Failed to fetch provider info for context limit:', providersResponse)
+        } else {
+          const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
+          const model = provider?.models?.[usedModel]
+          if (model?.limit?.context) {
+            modelContextLimit = model.limit.context
           }
+        }
+      }
 
-          if (part.type === 'reasoning') {
-            await sendPartMessage(part)
-          }
+      if (!modelContextLimit) {
+        return
+      }
 
-          // Send text parts when complete (time.end is set)
-          // Text parts stream incrementally; only send when finished to avoid partial text
-          if (part.type === 'text' && part.time?.end) {
-            await sendPartMessage(part)
-          }
+      const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100)
+      const thresholdCrossed = Math.floor(currentPercentage / 10) * 10
+      if (thresholdCrossed <= lastDisplayedContextPercentage || thresholdCrossed < 10) {
+        return
+      }
+      lastDisplayedContextPercentage = thresholdCrossed
+      const chunk = `⬦ context usage ${currentPercentage}%`
+      await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+    }
 
-          if (part.type === 'step-finish') {
-            for (const p of currentParts) {
-              if (p.type !== 'step-start' && p.type !== 'step-finish') {
-                await sendPartMessage(p)
-              }
+    const handleMainPart = async (part: Part) => {
+      const isActiveMessage = assistantMessageId ? part.messageID === assistantMessageId : false
+      const allowEarlyProcessing =
+        !assistantMessageId && part.type === 'tool' && part.state.status === 'running'
+      if (!isActiveMessage && !allowEarlyProcessing) {
+        if (part.type !== 'step-start') {
+          return
+        }
+      }
+
+      if (part.type === 'step-start') {
+        const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
+          (ctx) => ctx.thread.id === thread.id,
+        )
+        const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0
+        if (!hasPendingQuestion && !hasPendingPermission) {
+          stopTyping = startTyping()
+        }
+        return
+      }
+
+      if (part.type === 'tool' && part.state.status === 'running') {
+        await flushBufferedParts({
+          messageID: assistantMessageId || part.messageID,
+          force: true,
+          skipPartId: part.id,
+        })
+        await sendPartMessage(part)
+        if (part.tool === 'task' && !sentPartIds.has(part.id)) {
+          const description = (part.state.input?.description as string) || ''
+          const agent = (part.state.input?.subagent_type as string) || 'task'
+          const childSessionId = (part.state.metadata?.sessionId as string) || ''
+          if (description && childSessionId) {
+            agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1
+            const label = `${agent}-${agentSpawnCounts[agent]}`
+            subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined })
+            // Skip task messages in text-only mode
+            if (verbosity !== 'text-only') {
+              const taskDisplay = `┣ task **${label}** _${description}_`
+              await sendThreadMessage(thread, taskDisplay + '\n\n')
             }
-            setTimeout(() => {
-              if (abortController.signal.aborted) return
-              // Don't restart typing if user needs to respond to a question or permission
-              const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
-                (ctx) => ctx.thread.id === thread.id,
-              )
-              const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0
-              if (hasPendingQuestion || hasPendingPermission) return
-              stopTyping = startTyping()
-            }, 300)
+            sentPartIds.add(part.id)
           }
+        }
+        return
+      }
 
-        } else if (event.type === 'session.error') {
-          sessionLogger.error(`ERROR:`, event.properties)
-          if (event.properties.sessionID === session.id) {
-            const errorData = event.properties.error
-            const errorMessage = errorData?.data?.message || 'Unknown error'
-            sessionLogger.error(`Sending error to thread: ${errorMessage}`)
-            await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`)
-
-            if (originalMessage) {
-              try {
-                await originalMessage.reactions.removeAll()
-                await originalMessage.react('❌')
-                voiceLogger.log(`[REACTION] Added error reaction due to session error`)
-              } catch (e) {
-                discordLogger.log(`Could not update reaction:`, e)
-              }
+      if (part.type === 'tool' && part.state.status === 'completed') {
+        const output = part.state.output || ''
+        const outputTokens = Math.ceil(output.length / 4)
+        const largeOutputThreshold = 3000
+        if (outputTokens >= largeOutputThreshold) {
+          const formattedTokens =
+            outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens)
+          const percentageSuffix = (() => {
+            if (!modelContextLimit) {
+              return ''
             }
-          } else {
-            voiceLogger.log(
-              `[SESSION ERROR IGNORED] Error for different session (expected: ${session.id}, got: ${event.properties.sessionID})`,
-            )
-          }
-          break
-        } else if (event.type === 'permission.asked') {
-          const permission = event.properties
-          if (permission.sessionID !== session.id) {
-            voiceLogger.log(
-              `[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`,
-            )
-            continue
-          }
+            const pct = (outputTokens / modelContextLimit) * 100
+            if (pct < 1) {
+              return ''
+            }
+            return ` (${pct.toFixed(1)}%)`
+          })()
+          const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`
+          await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+        }
+      }
 
-          // Skip if this exact permission ID is already pending (dedupe)
-          const threadPermissions = pendingPermissions.get(thread.id)
-          if (threadPermissions?.has(permission.id)) {
-            sessionLogger.log(
-              `[PERMISSION] Skipping duplicate permission ${permission.id} (already pending)`,
-            )
-            continue
-          }
+      if (part.type === 'reasoning') {
+        await sendPartMessage(part)
+        return
+      }
 
-          sessionLogger.log(
-            `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
+      if (part.type === 'text' && part.time?.end) {
+        await sendPartMessage(part)
+        return
+      }
+
+      if (part.type === 'step-finish') {
+        await flushBufferedParts({
+          messageID: assistantMessageId || part.messageID,
+          force: true,
+        })
+        setTimeout(() => {
+          if (abortController.signal.aborted) return
+          const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
+            (ctx) => ctx.thread.id === thread.id,
           )
+          const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0
+          if (hasPendingQuestion || hasPendingPermission) return
+          stopTyping = startTyping()
+        }, 300)
+      }
+    }
 
-          // Stop typing - user needs to respond now, not the bot
-          if (stopTyping) {
-            stopTyping()
-            stopTyping = null
-          }
+    const handleSubtaskPart = async (
+      part: Part,
+      subtaskInfo: { label: string; assistantMessageId?: string },
+    ) => {
+      // In text-only mode, skip all subtask output (they're tool-related)
+      if (verbosity === 'text-only') {
+        return
+      }
+      if (part.type === 'step-start' || part.type === 'step-finish') {
+        return
+      }
+      if (part.type === 'tool' && part.state.status === 'pending') {
+        return
+      }
+      if (part.type === 'text') {
+        return
+      }
+      if (!subtaskInfo.assistantMessageId || part.messageID !== subtaskInfo.assistantMessageId) {
+        return
+      }
 
-          // Show dropdown instead of text message
-          const { messageId, contextHash } = await showPermissionDropdown({
-            thread,
-            permission,
-            directory,
-          })
+      const content = formatPart(part, subtaskInfo.label)
+      if (!content.trim() || sentPartIds.has(part.id)) {
+        return
+      }
+      const sendResult = await errore.tryAsync(() => {
+        return sendThreadMessage(thread, content + '\n\n')
+      })
+      if (sendResult instanceof Error) {
+        discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, sendResult)
+        return
+      }
+      sentPartIds.add(part.id)
+      getDatabase()
+        .prepare(
+          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+        )
+        .run(part.id, sendResult.id, thread.id)
+    }
 
-          // Track permission in nested map (threadId -> permissionId -> data)
-          if (!pendingPermissions.has(thread.id)) {
-            pendingPermissions.set(thread.id, new Map())
-          }
-          pendingPermissions.get(thread.id)!.set(permission.id, {
-            permission,
-            messageId,
-            directory,
-            contextHash,
-          })
-        } else if (event.type === 'permission.replied') {
-          const { requestID, reply, sessionID } = event.properties
-          if (sessionID !== session.id) {
-            continue
-          }
+    const handlePartUpdated = async (part: Part) => {
+      storePart(part)
 
-          sessionLogger.log(`Permission ${requestID} replied with: ${reply}`)
-
-          // Clean up the specific permission from nested map
-          const threadPermissions = pendingPermissions.get(thread.id)
-          if (threadPermissions) {
-            const pending = threadPermissions.get(requestID)
-            if (pending) {
-              cleanupPermissionContext(pending.contextHash)
-              threadPermissions.delete(requestID)
-              // Remove thread entry if no more pending permissions
-              if (threadPermissions.size === 0) {
-                pendingPermissions.delete(thread.id)
-              }
-            }
-          }
-        } else if (event.type === 'question.asked') {
-          const questionRequest = event.properties
+      const subtaskInfo = subtaskSessions.get(part.sessionID)
+      const isSubtaskEvent = Boolean(subtaskInfo)
 
-          if (questionRequest.sessionID !== session.id) {
-            sessionLogger.log(
-              `[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`,
-            )
-            continue
-          }
+      if (part.sessionID !== session.id && !isSubtaskEvent) {
+        return
+      }
+
+      if (isSubtaskEvent && subtaskInfo) {
+        await handleSubtaskPart(part, subtaskInfo)
+        return
+      }
+
+      await handleMainPart(part)
+    }
+
+    const handleSessionError = async ({
+      sessionID,
+      error,
+    }: {
+      sessionID?: string
+      error?: { data?: { message?: string } }
+    }) => {
+      if (!sessionID || sessionID !== session.id) {
+        voiceLogger.log(
+          `[SESSION ERROR IGNORED] Error for different session (expected: ${session.id}, got: ${sessionID})`,
+        )
+        return
+      }
+
+      const errorMessage = error?.data?.message || 'Unknown error'
+      sessionLogger.error(`Sending error to thread: ${errorMessage}`)
+      await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`)
+
+      if (!originalMessage) {
+        return
+      }
+      const reactionResult = await errore.tryAsync(async () => {
+        await originalMessage.reactions.removeAll()
+        await originalMessage.react('❌')
+      })
+      if (reactionResult instanceof Error) {
+        discordLogger.log(`Could not update reaction:`, reactionResult)
+      } else {
+        voiceLogger.log(`[REACTION] Added error reaction due to session error`)
+      }
+    }
+
+    const handlePermissionAsked = async (permission: PermissionRequest) => {
+      if (permission.sessionID !== session.id) {
+        voiceLogger.log(
+          `[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`,
+        )
+        return
+      }
+
+      const dedupeKey = buildPermissionDedupeKey({ permission, directory })
+      const threadPermissions = pendingPermissions.get(thread.id)
+      const existingPending = threadPermissions
+        ? Array.from(threadPermissions.values()).find((pending) => {
+            return pending.dedupeKey === dedupeKey
+          })
+        : undefined
 
+      if (existingPending) {
+        sessionLogger.log(
+          `[PERMISSION] Deduped permission ${permission.id} (matches pending ${existingPending.permission.id})`,
+        )
+        if (stopTyping) {
+          stopTyping()
+          stopTyping = null
+        }
+        if (!pendingPermissions.has(thread.id)) {
+          pendingPermissions.set(thread.id, new Map())
+        }
+        pendingPermissions.get(thread.id)!.set(permission.id, {
+          permission,
+          messageId: existingPending.messageId,
+          directory,
+          contextHash: existingPending.contextHash,
+          dedupeKey,
+        })
+        const added = addPermissionRequestToContext({
+          contextHash: existingPending.contextHash,
+          requestId: permission.id,
+        })
+        if (!added) {
           sessionLogger.log(
-            `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
+            `[PERMISSION] Failed to attach duplicate request ${permission.id} to context`,
           )
+        }
+        return
+      }
 
-          // Stop typing - user needs to respond now, not the bot
-          if (stopTyping) {
-            stopTyping()
-            stopTyping = null
-          }
+      sessionLogger.log(
+        `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
+      )
 
-          // Flush any pending text/reasoning parts before showing the dropdown
-          // This ensures text the LLM generated before the question tool is shown first
-          for (const p of currentParts) {
-            if (p.type !== 'step-start' && p.type !== 'step-finish') {
-              await sendPartMessage(p)
-            }
-          }
+      if (stopTyping) {
+        stopTyping()
+        stopTyping = null
+      }
 
-          await showAskUserQuestionDropdowns({
-            thread,
-            sessionId: session.id,
-            directory,
-            requestId: questionRequest.id,
-            input: { questions: questionRequest.questions },
-          })
+      const { messageId, contextHash } = await showPermissionDropdown({
+        thread,
+        permission,
+        directory,
+      })
 
-          // Process queued messages if any - queued message will cancel the pending question
-          const queue = messageQueue.get(thread.id)
-          if (queue && queue.length > 0) {
-            const nextMessage = queue.shift()!
-            if (queue.length === 0) {
-              messageQueue.delete(thread.id)
-            }
+      if (!pendingPermissions.has(thread.id)) {
+        pendingPermissions.set(thread.id, new Map())
+      }
+      pendingPermissions.get(thread.id)!.set(permission.id, {
+        permission,
+        messageId,
+        directory,
+        contextHash,
+        dedupeKey,
+      })
+    }
 
-            sessionLogger.log(
-              `[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`,
-            )
+    const handlePermissionReplied = ({
+      requestID,
+      reply,
+      sessionID,
+    }: {
+      requestID: string
+      reply: string
+      sessionID: string
+    }) => {
+      if (sessionID !== session.id) {
+        return
+      }
 
+      sessionLogger.log(`Permission ${requestID} replied with: ${reply}`)
+
+      const threadPermissions = pendingPermissions.get(thread.id)
+      if (!threadPermissions) {
+        return
+      }
+      const pending = threadPermissions.get(requestID)
+      if (!pending) {
+        return
+      }
+      cleanupPermissionContext(pending.contextHash)
+      threadPermissions.delete(requestID)
+      if (threadPermissions.size === 0) {
+        pendingPermissions.delete(thread.id)
+      }
+    }
+
+    const handleQuestionAsked = async (questionRequest: QuestionRequest) => {
+      if (questionRequest.sessionID !== session.id) {
+        sessionLogger.log(
+          `[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`,
+        )
+        return
+      }
+
+      sessionLogger.log(
+        `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
+      )
+
+      if (stopTyping) {
+        stopTyping()
+        stopTyping = null
+      }
+
+      await flushBufferedParts({
+        messageID: assistantMessageId || '',
+        force: true,
+      })
+
+      await showAskUserQuestionDropdowns({
+        thread,
+        sessionId: session.id,
+        directory,
+        requestId: questionRequest.id,
+        input: { questions: questionRequest.questions },
+      })
+
+      const queue = messageQueue.get(thread.id)
+      if (!queue || queue.length === 0) {
+        return
+      }
+
+      const nextMessage = queue.shift()!
+      if (queue.length === 0) {
+        messageQueue.delete(thread.id)
+      }
+
+      sessionLogger.log(
+        `[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`,
+      )
+
+      await sendThreadMessage(
+        thread,
+        `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`,
+      )
+
+      setImmediate(() => {
+        void errore
+          .tryAsync(async () => {
+            return handleOpencodeSession({
+              prompt: nextMessage.prompt,
+              thread,
+              projectDirectory: directory,
+              images: nextMessage.images,
+              channelId,
+            })
+          })
+          .then(async (result) => {
+            if (!(result instanceof Error)) {
+              return
+            }
+            sessionLogger.error(`[QUEUE] Failed to process queued message:`, result)
             await sendThreadMessage(
               thread,
-              `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`,
+              `✗ Queued message failed: ${result.message.slice(0, 200)}`,
             )
+          })
+      })
+    }
 
-            // handleOpencodeSession will call cancelPendingQuestion, which cancels the dropdown
-            setImmediate(() => {
-              handleOpencodeSession({
-                prompt: nextMessage.prompt,
-                thread,
-                projectDirectory: directory,
-                images: nextMessage.images,
-                channelId,
-              }).catch(async (e) => {
-                sessionLogger.error(`[QUEUE] Failed to process queued message:`, e)
-                const errorMsg = e instanceof Error ? e.message : String(e)
-                await sendThreadMessage(
-                  thread,
-                  `✗ Queued message failed: ${errorMsg.slice(0, 200)}`,
-                )
-              })
-            })
-          }
-        } else if (event.type === 'session.idle') {
-          const idleSessionId = event.properties.sessionID
-          // Session is done processing - abort to signal completion
-          if (idleSessionId === session.id) {
-            sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
-            abortController.abort('finished')
-          } else if (subtaskSessions.has(idleSessionId)) {
-            // Child session completed - clean up tracking
-            const subtask = subtaskSessions.get(idleSessionId)
-            sessionLogger.log(`[SUBTASK IDLE] Subtask "${subtask?.label}" completed`)
-            subtaskSessions.delete(idleSessionId)
-          }
+    const handleSessionIdle = (idleSessionId: string) => {
+      if (idleSessionId === session.id) {
+        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
+        abortController.abort('finished')
+        return
+      }
+
+      if (!subtaskSessions.has(idleSessionId)) {
+        return
+      }
+      const subtask = subtaskSessions.get(idleSessionId)
+      sessionLogger.log(`[SUBTASK IDLE] Subtask "${subtask?.label}" completed`)
+      subtaskSessions.delete(idleSessionId)
+    }
+
+    try {
+      for await (const event of events) {
+        switch (event.type) {
+          case 'message.updated':
+            await handleMessageUpdated(event.properties.info)
+            break
+          case 'message.part.updated':
+            await handlePartUpdated(event.properties.part)
+            break
+          case 'session.error':
+            sessionLogger.error(`ERROR:`, event.properties)
+            await handleSessionError(event.properties)
+            break
+          case 'permission.asked':
+            await handlePermissionAsked(event.properties)
+            break
+          case 'permission.replied':
+            handlePermissionReplied(event.properties)
+            break
+          case 'question.asked':
+            await handleQuestionAsked(event.properties)
+            break
+          case 'session.idle':
+            handleSessionIdle(event.properties.sessionID)
+            break
+          default:
+            break
         }
       }
     } catch (e) {
@@ -808,12 +1063,13 @@ export async function handleOpencodeSession({
       sessionLogger.error(`Unexpected error in event handling code`, e)
       throw e
     } finally {
-      for (const part of currentParts) {
-        if (!sentPartIds.has(part.id)) {
-          try {
+      abortControllers.delete(session.id)
+      const finalMessageId = assistantMessageId
+      if (finalMessageId) {
+        const parts = getBufferedParts(finalMessageId)
+        for (const part of parts) {
+          if (!sentPartIds.has(part.id)) {
             await sendPartMessage(part)
-          } catch (error) {
-            sessionLogger.error(`Failed to send part ${part.id}:`, error)
           }
         }
       }
@@ -831,12 +1087,13 @@ export async function handleOpencodeSession({
           usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : ''
         let contextInfo = ''
 
-        try {
+        const contextResult = await errore.tryAsync(async () => {
           // Fetch final token count from API since message.updated events can arrive
           // after session.idle due to race conditions in event ordering
           if (tokensUsedInSession === 0) {
             const messagesResponse = await getClient().session.messages({
               path: { id: session.id },
+              query: { directory: sdkDirectory },
             })
             const messages = messagesResponse.data || []
             const lastAssistant = [...messages]
@@ -858,15 +1115,16 @@ export async function handleOpencodeSession({
             }
           }
 
-          const providersResponse = await getClient().provider.list({ query: { directory } })
+          const providersResponse = await getClient().provider.list({ query: { directory: sdkDirectory } })
           const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
           const model = provider?.models?.[usedModel || '']
           if (model?.limit?.context) {
             const percentage = Math.round((tokensUsedInSession / model.limit.context) * 100)
             contextInfo = ` ⋅ ${percentage}%`
           }
-        } catch (e) {
-          sessionLogger.error('Failed to fetch provider info for context percentage:', e)
+        })
+        if (contextResult instanceof Error) {
+          sessionLogger.error('Failed to fetch provider info for context percentage:', contextResult)
         }
 
         await sendThreadMessage(
@@ -918,8 +1176,15 @@ export async function handleOpencodeSession({
     }
   }
 
-  try {
-    const eventHandlerPromise = eventHandler()
+  const promptResult: Error | { sessionID: string; result: any; port?: number } | undefined =
+    await errore.tryAsync(async () => {
+      const newHandlerPromise = eventHandler().finally(() => {
+        if (activeEventHandlers.get(thread.id) === newHandlerPromise) {
+          activeEventHandlers.delete(thread.id)
+        }
+      })
+      activeEventHandlers.set(thread.id, newHandlerPromise)
+      handlerPromise = newHandlerPromise
 
     if (abortController.signal.aborted) {
       sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`)
@@ -931,7 +1196,6 @@ export async function handleOpencodeSession({
     voiceLogger.log(
       `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
     )
-    // append image paths to prompt so ai knows where they are on disk
     const promptWithImagePaths = (() => {
       if (images.length === 0) {
         return prompt
@@ -951,19 +1215,15 @@ export async function handleOpencodeSession({
     const parts = [{ type: 'text' as const, text: promptWithImagePaths }, ...images]
     sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
 
-    // Get agent preference: session-level overrides channel-level
     const agentPreference =
       getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined)
     if (agentPreference) {
       sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`)
     }
 
-    // Get model preference: session-level overrides channel-level
-    // BUT: if an agent is set, don't pass model param so the agent's model takes effect
     const modelPreference =
       getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
     const modelParam = (() => {
-      // When an agent is set, let the agent's model config take effect
       if (agentPreference) {
         sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`)
         return undefined
@@ -980,8 +1240,7 @@ export async function handleOpencodeSession({
       return { providerID, modelID }
     })()
 
-    // Get worktree info if this thread is in a worktree
-    const worktreeInfo = getThreadWorktree(thread.id)
+    // Build worktree info for system message (worktreeInfo was fetched at the start)
     const worktree: WorktreeInfo | undefined =
       worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
         ? {
@@ -991,10 +1250,10 @@ export async function handleOpencodeSession({
           }
         : undefined
 
-    // Use session.command API for slash commands, session.prompt for regular messages
     const response = command
       ? await getClient().session.command({
           path: { id: session.id },
+          query: { directory: sdkDirectory },
           body: {
             command: command.name,
             arguments: command.arguments,
@@ -1004,6 +1263,7 @@ export async function handleOpencodeSession({
         })
       : await getClient().session.prompt({
           path: { id: session.id },
+          query: { directory: sdkDirectory },
           body: {
             parts,
             system: getOpencodeSystemMessage({ sessionId: session.id, channelId, worktree }),
@@ -1034,40 +1294,55 @@ export async function handleOpencodeSession({
     sessionLogger.log(`Successfully sent prompt, got response`)
 
     if (originalMessage) {
-      try {
+      const reactionResult = await errore.tryAsync(async () => {
         await originalMessage.reactions.removeAll()
         await originalMessage.react('✅')
-      } catch (e) {
-        discordLogger.log(`Could not update reactions:`, e)
+      })
+      if (reactionResult instanceof Error) {
+        discordLogger.log(`Could not update reactions:`, reactionResult)
       }
     }
 
     return { sessionID: session.id, result: response.data, port }
-  } catch (error) {
-    if (!isAbortError(error, abortController.signal)) {
-      sessionLogger.error(`ERROR: Failed to send prompt:`, error)
-      abortController.abort('error')
-
-      if (originalMessage) {
-        try {
-          await originalMessage.reactions.removeAll()
-          await originalMessage.react('❌')
-          discordLogger.log(`Added error reaction to message`)
-        } catch (e) {
-          discordLogger.log(`Could not update reaction:`, e)
-        }
-      }
-      const errorDisplay = (() => {
-        if (error instanceof Error) {
-          const name = error.constructor.name || 'Error'
-          return `[${name}]\n${error.stack || error.message}`
-        }
-        if (typeof error === 'string') {
-          return error
-        }
-        return String(error)
-      })()
-      await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`)
+  })
+
+  if (handlerPromise) {
+    await Promise.race([
+      handlerPromise,
+      new Promise((resolve) => {
+        setTimeout(resolve, 1000)
+      }),
+    ])
+  }
+
+  if (!errore.isError(promptResult)) {
+    return promptResult
+  }
+
+  const promptError: Error = promptResult instanceof Error ? promptResult : new Error('Unknown error')
+  if (isAbortError(promptError, abortController.signal)) {
+    return
+  }
+
+  sessionLogger.error(`ERROR: Failed to send prompt:`, promptError)
+  abortController.abort('error')
+
+  if (originalMessage) {
+    const reactionResult = await errore.tryAsync(async () => {
+      await originalMessage.reactions.removeAll()
+      await originalMessage.react('❌')
+    })
+    if (reactionResult instanceof Error) {
+      discordLogger.log(`Could not update reaction:`, reactionResult)
+    } else {
+      discordLogger.log(`Added error reaction to message`)
     }
   }
+  const errorDisplay = (() => {
+    const promptErrorValue = promptError as unknown as Error
+    const name = promptErrorValue.name || 'Error'
+    const message = promptErrorValue.stack || promptErrorValue.message
+    return `[${name}]\n${message}`
+  })()
+  await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`)
 }