kimaki 0.4.47 → 0.4.49

package/src/discord-bot.ts

@@ -77,6 +77,10 @@ setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections:
 const discordLogger = createLogger(LogPrefix.DISCORD)
 const voiceLogger = createLogger(LogPrefix.VOICE)
 
+function prefixWithDiscordUser({ username, prompt }: { username: string; prompt: string }): string {
+  return `<discord-user name="${username}" />\n${prompt}`
+}
+
 type StartOptions = {
   token: string
   appId?: string
@@ -165,6 +169,17 @@ export async function startDiscordBot({
       if (message.author?.bot) {
         return
       }
+
+      // Ignore messages that start with a mention of another user (not the bot).
+      // These are likely users talking to each other, not the bot.
+      const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/)
+      if (leadingMentionMatch) {
+        const mentionedUserId = leadingMentionMatch[1]
+        if (mentionedUserId !== discordClient.user?.id) {
+          return
+        }
+      }
+
       if (message.partial) {
         discordLogger.log(`Fetching partial message ${message.id}`)
         const fetched = await errore.tryAsync({
@@ -275,13 +290,19 @@ export async function startDiscordBot({
 
           // Include starter message as context for the session
           let prompt = message.content
-          const starterMessage = await thread.fetchStarterMessage().catch(() => null)
+          const starterMessage = await thread.fetchStarterMessage().catch((error) => {
+            discordLogger.warn(
+              `[SESSION] Failed to fetch starter message for thread ${thread.id}:`,
+              error instanceof Error ? error.message : String(error),
+            )
+            return null
+          })
           if (starterMessage?.content && starterMessage.content !== message.content) {
             prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`
           }
 
           await handleOpencodeSession({
-            prompt,
+            prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt }),
             thread,
             projectDirectory,
             channelId: parent?.id || '',
@@ -358,7 +379,7 @@ export async function startDiscordBot({
           ? `${messageContent}\n\n${textAttachmentsContent}`
           : messageContent
         await handleOpencodeSession({
-          prompt: promptWithAttachments,
+          prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt: promptWithAttachments }),
           thread,
           projectDirectory,
           originalMessage: message,
@@ -502,7 +523,7 @@ export async function startDiscordBot({
           ? `${messageContent}\n\n${textAttachmentsContent}`
           : messageContent
         await handleOpencodeSession({
-          prompt: promptWithAttachments,
+          prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt: promptWithAttachments }),
           thread,
           projectDirectory: sessionDirectory,
           originalMessage: message,
@@ -517,8 +538,11 @@ export async function startDiscordBot({
       try {
         const errMsg = error instanceof Error ? error.message : String(error)
         await message.reply({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS })
-      } catch {
-        voiceLogger.error('Discord handler error (fallback):', error)
+      } catch (sendError) {
+        voiceLogger.error(
+          'Discord handler error (fallback):',
+          sendError instanceof Error ? sendError.message : String(sendError),
+        )
       }
     }
   })
@@ -539,7 +563,13 @@ export async function startDiscordBot({
       }
 
       // Get the starter message to check for auto-start marker
-      const starterMessage = await thread.fetchStarterMessage().catch(() => null)
+      const starterMessage = await thread.fetchStarterMessage().catch((error) => {
+        discordLogger.warn(
+          `[THREAD_CREATE] Failed to fetch starter message for thread ${thread.id}:`,
+          error instanceof Error ? error.message : String(error),
+        )
+        return null
+      })
       if (!starterMessage) {
         discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`)
         return
@@ -601,8 +631,11 @@ export async function startDiscordBot({
       try {
         const errMsg = error instanceof Error ? error.message : String(error)
         await thread.send({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS })
-      } catch {
-        // Ignore send errors
+      } catch (sendError) {
+        voiceLogger.error(
+          '[BOT_SESSION] Failed to send error message:',
+          sendError instanceof Error ? sendError.message : String(sendError),
+        )
       }
     }
   })

package/src/message-formatting.ts

@@ -29,6 +29,74 @@ function escapeInlineMarkdown(text: string): string {
   return text.replace(/([*_~|`\\])/g, '\\$1')
 }
 
+/**
+ * Parses a patchText string (apply_patch format) and counts additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+function parsePatchCounts(
+  patchText: string,
+): Map<string, { additions: number; deletions: number }> {
+  const counts = new Map<string, { additions: number; deletions: number }>()
+  const lines = patchText.split('\n')
+  let currentFile = ''
+  let currentType = ''
+  let inHunk = false
+
+  for (const line of lines) {
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/)
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/)
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/)
+
+    if (addMatch || updateMatch || deleteMatch) {
+      const match = addMatch || updateMatch || deleteMatch
+      currentFile = (match?.[1] ?? '').trim()
+      currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete'
+      counts.set(currentFile, { additions: 0, deletions: 0 })
+      inHunk = false
+      continue
+    }
+
+    if (line.startsWith('@@')) {
+      inHunk = true
+      continue
+    }
+
+    if (line.startsWith('*** ')) {
+      inHunk = false
+      continue
+    }
+
+    if (!currentFile) {
+      continue
+    }
+
+    const entry = counts.get(currentFile)
+    if (!entry) {
+      continue
+    }
+
+    if (currentType === 'add') {
+      // all content lines in Add File are additions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.additions++
+      }
+    } else if (currentType === 'delete') {
+      // all content lines in Delete File are deletions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.deletions++
+      }
+    } else if (inHunk) {
+      if (line.startsWith('+')) {
+        entry.additions++
+      } else if (line.startsWith('-')) {
+        entry.deletions++
+      }
+    }
+  }
+  return counts
+}
+
 /**
  * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
  */
@@ -178,70 +246,20 @@ export function getToolSummaryText(part: Part): string {
   }
 
   if (part.tool === 'apply_patch') {
-    const state = part.state as {
-      metadata?: { files?: unknown; diff?: unknown }
-      output?: unknown
-    }
-    const rawFiles = state.metadata?.files
-    const partMetaFiles = (part as { metadata?: { files?: unknown } }).metadata?.files
-    const filesList = Array.isArray(rawFiles)
-      ? rawFiles
-      : Array.isArray(partMetaFiles)
-        ? partMetaFiles
-        : []
-
-    const summarizeFiles = (files: unknown[]): string => {
-      const summarized = files
-        .map((f) => {
-          if (!f) {
-            return null
-          }
-          if (typeof f === 'string') {
-            const fileName = f.split('/').pop() || ''
-            return fileName ? `*${escapeInlineMarkdown(fileName)}* (+0-0)` : `(+0-0)`
-          }
-          if (typeof f !== 'object') {
-            return null
-          }
-          const file = f as Record<string, unknown>
-          const pathStr = String(file.relativePath || file.filePath || file.path || '')
-          const fileName = pathStr.split('/').pop() || ''
-          const added = typeof file.additions === 'number' ? file.additions : 0
-          const removed = typeof file.deletions === 'number' ? file.deletions : 0
-          return fileName
-            ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
-            : `(+${added}-${removed})`
-        })
-        .filter(Boolean)
-        .join(', ')
-      return summarized
-    }
-
-    if (filesList.length > 0) {
-      const summarized = summarizeFiles(filesList)
-      if (summarized) {
-        return summarized
-      }
-    }
-
-    const outputText = typeof state.output === 'string' ? state.output : ''
-    const outputLines = outputText.split('\n')
-    const updatedIndex = outputLines.findIndex((line) =>
-      line.startsWith('Success. Updated the following files:'),
-    )
-    if (updatedIndex !== -1) {
-      const fileLines = outputLines.slice(updatedIndex + 1).filter(Boolean)
-      if (fileLines.length > 0) {
-        const summarized = summarizeFiles(
-          fileLines.map((line) => line.replace(/^[AMD]\s+/, '').trim()),
-        )
-        if (summarized) {
-          return summarized
-        }
-      }
+    // Only inputs are available when parts are sent during streaming (output/metadata not yet populated)
+    const patchText = (part.state.input?.patchText as string) || ''
+    if (!patchText) {
+      return ''
     }
-
-    return ''
+    const patchCounts = parsePatchCounts(patchText)
+    return [...patchCounts.entries()]
+      .map(([filePath, { additions, deletions }]) => {
+        const fileName = filePath.split('/').pop() || ''
+        return fileName
+          ? `*${escapeInlineMarkdown(fileName)}* (+${additions}-${deletions})`
+          : `(+${additions}-${deletions})`
+      })
+      .join(', ')
   }
 
   if (part.tool === 'write') {

package/src/opencode.ts

@@ -54,31 +54,24 @@ async function getOpenPort(): Promise<number> {
 }
 
 async function waitForServer(port: number, maxAttempts = 30): Promise<ServerStartError | true> {
+  const endpoint = `http://127.0.0.1:${port}/api/health`
   for (let i = 0; i < maxAttempts; i++) {
-    const endpoints = [
-      `http://127.0.0.1:${port}/api/health`,
-      `http://127.0.0.1:${port}/`,
-      `http://127.0.0.1:${port}/api`,
-    ]
-
-    for (const endpoint of endpoints) {
-      const response = await errore.tryAsync({
-        try: () => fetch(endpoint),
-        catch: (e) => new FetchError({ url: endpoint, cause: e }),
-      })
-      if (response instanceof Error) {
-        // Connection refused or other transient errors - continue polling
-        opencodeLogger.debug(`Server polling attempt failed: ${response.message}`)
-        continue
-      }
-      if (response.status < 500) {
-        return true
-      }
-      const body = await response.text()
-      // Fatal errors that won't resolve with retrying
-      if (body.includes('BunInstallFailedError')) {
-        return new ServerStartError({ port, reason: body.slice(0, 200) })
-      }
+    const response = await errore.tryAsync({
+      try: () => fetch(endpoint),
+      catch: (e) => new FetchError({ url: endpoint, cause: e }),
+    })
+    if (response instanceof Error) {
+      // Connection refused or other transient errors - continue polling
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+      continue
+    }
+    if (response.status < 500) {
+      return true
+    }
+    const body = await response.text()
+    // Fatal errors that won't resolve with retrying
+    if (body.includes('BunInstallFailedError')) {
+      return new ServerStartError({ port, reason: body.slice(0, 200) })
     }
     await new Promise((resolve) => setTimeout(resolve, 1000))
   }

package/src/session-handler.ts

@@ -134,6 +134,7 @@ export async function abortAndRetrySession({
   sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`)
 
   // Abort with special reason so we don't show "completed" message
+  sessionLogger.log(`[ABORT] reason=model-change sessionId=${sessionId} - user changed model mid-request, will retry with new model`)
   controller.abort(new Error('model-change'))
 
   // Also call the API abort endpoint
@@ -142,11 +143,12 @@ export async function abortAndRetrySession({
     sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message)
     return false
   }
+  sessionLogger.log(`[ABORT-API] reason=model-change sessionId=${sessionId} - sending API abort for model change retry`)
   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)
+    sessionLogger.log(`[ABORT-API] API abort call failed (may already be done):`, abortResult)
   }
 
   // Small delay to let the abort propagate
@@ -302,7 +304,9 @@ export async function handleOpencodeSession({
   const existingController = abortControllers.get(session.id)
   if (existingController) {
     voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`)
+    sessionLogger.log(`[ABORT] reason=new-request sessionId=${session.id} threadId=${thread.id} - new user message arrived while previous request was still running`)
     existingController.abort(new Error('New request started'))
+    sessionLogger.log(`[ABORT-API] reason=new-request sessionId=${session.id} - sending API abort because new message arrived`)
     const abortResult = await errore.tryAsync(() => {
       return getClient().session.abort({
         path: { id: session.id },
@@ -310,7 +314,7 @@ export async function handleOpencodeSession({
       })
     })
     if (abortResult instanceof Error) {
-      sessionLogger.log(`[ABORT] Server abort failed (may be already done):`, abortResult)
+      sessionLogger.log(`[ABORT-API] Server abort failed (may be already done):`, abortResult)
     }
   }
 
@@ -424,6 +428,9 @@ export async function handleOpencodeSession({
   let handlerPromise: Promise<void> | null = null
 
   let typingInterval: NodeJS.Timeout | null = null
+  let hasSentParts = false
+  let promptResolved = false
+  let hasReceivedEvent = false
 
   function startTyping(): () => void {
     if (abortController.signal.aborted) {
@@ -470,13 +477,15 @@ export async function handleOpencodeSession({
     }
   }
 
-  // Get verbosity setting for this channel (use parent channel for threads)
+  // Read verbosity dynamically so mid-session /verbosity changes take effect immediately
   const verbosityChannelId = channelId || thread.parentId || thread.id
-  const verbosity = getChannelVerbosity(verbosityChannelId)
+  const getVerbosity = () => {
+    return 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') {
+    if (getVerbosity() === 'text-only' && part.type !== 'text') {
       return
     }
 
@@ -497,6 +506,7 @@ export async function handleOpencodeSession({
       discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult)
       return
     }
+    hasSentParts = true
     sentPartIds.add(part.id)
 
     getDatabase()
@@ -588,6 +598,7 @@ export async function handleOpencodeSession({
       if (msg.sessionID !== session.id) {
         return
       }
+      hasReceivedEvent = true
 
       if (msg.role !== 'assistant') {
         return
@@ -687,7 +698,7 @@ export async function handleOpencodeSession({
             const label = `${agent}-${agentSpawnCounts[agent]}`
             subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined })
             // Skip task messages in text-only mode
-            if (verbosity !== 'text-only') {
+            if (getVerbosity() !== 'text-only') {
               const taskDisplay = `┣ task **${label}** _${description}_`
               await sendThreadMessage(thread, taskDisplay + '\n\n')
             }
@@ -697,7 +708,7 @@ export async function handleOpencodeSession({
         return
       }
 
-      if (part.type === 'tool' && part.state.status === 'completed') {
+      if (part.type === 'tool' && part.state.status === 'completed' && getVerbosity() !== 'text-only') {
         const output = part.state.output || ''
         const outputTokens = Math.ceil(output.length / 4)
         const largeOutputThreshold = 3000
@@ -751,7 +762,7 @@ export async function handleOpencodeSession({
       subtaskInfo: { label: string; assistantMessageId?: string },
     ) => {
       // In text-only mode, skip all subtask output (they're tool-related)
-      if (verbosity === 'text-only') {
+      if (getVerbosity() === 'text-only') {
         return
       }
       if (part.type === 'step-start' || part.type === 'step-finish') {
@@ -837,13 +848,20 @@ export async function handleOpencodeSession({
     }
 
     const handlePermissionAsked = async (permission: PermissionRequest) => {
-      if (permission.sessionID !== session.id) {
+      const isMainSession = permission.sessionID === session.id
+      const isSubtaskSession = subtaskSessions.has(permission.sessionID)
+
+      if (!isMainSession && !isSubtaskSession) {
         voiceLogger.log(
-          `[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`,
+          `[PERMISSION IGNORED] Permission for unknown session (expected: ${session.id} or subtask, got: ${permission.sessionID})`,
         )
         return
       }
 
+      const subtaskLabel = isSubtaskSession
+        ? subtaskSessions.get(permission.sessionID)?.label
+        : undefined
+
       const dedupeKey = buildPermissionDedupeKey({ permission, directory })
       const threadPermissions = pendingPermissions.get(thread.id)
       const existingPending = threadPermissions
@@ -883,7 +901,7 @@ export async function handleOpencodeSession({
       }
 
       sessionLogger.log(
-        `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
+        `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}${subtaskLabel ? `, subtask=${subtaskLabel}` : ''}`,
       )
 
       if (stopTyping) {
@@ -895,6 +913,7 @@ export async function handleOpencodeSession({
         thread,
         permission,
         directory,
+        subtaskLabel,
       })
 
       if (!pendingPermissions.has(thread.id)) {
@@ -918,7 +937,10 @@ export async function handleOpencodeSession({
       reply: string
       sessionID: string
     }) => {
-      if (sessionID !== session.id) {
+      const isMainSession = sessionID === session.id
+      const isSubtaskSession = subtaskSessions.has(sessionID)
+
+      if (!isMainSession && !isSubtaskSession) {
         return
       }
 
@@ -989,10 +1011,11 @@ export async function handleOpencodeSession({
       )
 
       setImmediate(() => {
+        const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`
         void errore
           .tryAsync(async () => {
             return handleOpencodeSession({
-              prompt: nextMessage.prompt,
+              prompt: prefixedPrompt,
               thread,
               projectDirectory: directory,
               images: nextMessage.images,
@@ -1048,16 +1071,14 @@ export async function handleOpencodeSession({
 
     const handleSessionIdle = (idleSessionId: string) => {
       if (idleSessionId === session.id) {
-        // Ignore stale session.idle events - if we haven't received any content yet
-        // (no assistantMessageId set), this is likely a stale event from before
-        // the prompt was sent or from a previous request's subscription state.
-        if (!assistantMessageId) {
+        if (!promptResolved || !hasReceivedEvent) {
           sessionLogger.log(
-            `[SESSION IDLE] Ignoring stale idle event for ${session.id} (no content received yet)`,
+            `[SESSION IDLE] Ignoring idle event for ${session.id} (prompt not resolved or no events yet)`,
           )
           return
         }
-        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
+        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, ending stream`)
+        sessionLogger.log(`[ABORT] reason=finished sessionId=${session.id} threadId=${thread.id} - session completed normally, received idle event after prompt resolved`)
         abortController.abort(new Error('finished'))
         return
       }
@@ -1203,8 +1224,9 @@ export async function handleOpencodeSession({
           // Send the queued message as a new prompt (recursive call)
           // Use setImmediate to avoid blocking and allow this finally to complete
           setImmediate(() => {
+            const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`
             handleOpencodeSession({
-              prompt: nextMessage.prompt,
+              prompt: prefixedPrompt,
               thread,
               projectDirectory,
               images: nextMessage.images,
@@ -1298,6 +1320,8 @@ export async function handleOpencodeSession({
           }
         : undefined
 
+    hasSentParts = false
+
     const response = command
       ? await getClient().session.command({
           path: { id: session.id },
@@ -1337,7 +1361,7 @@ export async function handleOpencodeSession({
       throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`)
     }
 
-    abortController.abort(new Error('finished'))
+    promptResolved = true
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
@@ -1373,6 +1397,7 @@ export async function handleOpencodeSession({
   }
 
   sessionLogger.error(`ERROR: Failed to send prompt:`, promptError)
+  sessionLogger.log(`[ABORT] reason=error sessionId=${session.id} threadId=${thread.id} - prompt failed with error: ${(promptError as Error).message}`)
   abortController.abort(new Error('error'))
 
   if (originalMessage) {

package/src/system-message.ts

@@ -133,19 +133,21 @@ headings are discouraged anyway. instead try to use bold text for titles which r
 
 you can create diagrams wrapping them in code blocks.
 
-## ending conversations with options
+## proactivity
 
-IMPORTANT: At the end of each response, especially after completing a task or presenting a plan, use the question tool to offer the user clear options for what to do next.
+Be proactive. When the user asks you to do something, do it. Do NOT stop to ask for confirmation.
 
-IMPORTANT: The question tool must be called last, after all text parts. If it is called before your final text response, the user will not see the text.
+Only ask questions when the request is genuinely ambiguous with multiple valid approaches, or the action is destructive and irreversible.
 
-Examples:
-- After showing a plan: offer "Start implementing?" with Yes/No options
-- After completing edits: offer "Commit changes?" with Yes/No options
-- After debugging: offer "How to proceed?" with options like "Apply fix", "Investigate further", "Try different approach"
+## ending conversations with options
 
-The user can always select "Other" to type a custom response if the provided options don't fit their needs, or if the plan needs updating.
+After **completing** a task, use the question tool to offer follow-up options. The question tool must be called last, after all text parts.
 
-This makes the interaction more guided and reduces friction for the user.
+IMPORTANT: Do NOT use the question tool to ask permission before doing work. Do the work first, then offer follow-ups.
+
+Examples:
+- After completing edits: offer "Commit changes?" or "Run tests?"
+- After debugging: offer "Apply fix", "Investigate further", "Try different approach"
+- After a genuinely ambiguous request where you cannot infer intent: offer the different approaches
 `
 }

package/src/tools.ts

@@ -343,6 +343,7 @@ export async function getTools({
       }),
       execute: async ({ sessionId }) => {
         try {
+          toolsLogger.log(`[ABORT] reason=voice-tool sessionId=${sessionId} - user requested abort via voice assistant tool`)
           const result = await getClient().session.abort({
             path: { id: sessionId },
           })

package/src/utils.ts

@@ -73,6 +73,7 @@ export function isAbortError(error: unknown, signal?: AbortSignal): error is Err
         error.name === 'Aborterror' ||
         error.name === 'aborterror' ||
         error.name.toLowerCase() === 'aborterror' ||
+        error.name === 'MessageAbortedError' ||
         error.message?.includes('aborted') ||
         (signal?.aborted ?? false))) ||
     (error instanceof DOMException && error.name === 'AbortError')