kimaki 0.4.46 → 0.4.48

package/src/openai-realtime.ts

@@ -5,9 +5,9 @@
 import { RealtimeClient } from '@openai/realtime-api-beta'
 import { writeFile } from 'fs'
 import type { Tool } from 'ai'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const openaiLogger = createLogger('OPENAI')
+const openaiLogger = createLogger(LogPrefix.OPENAI)
 
 // Export the session type for reuse
 export interface OpenAIRealtimeSession {

package/src/opencode.ts

@@ -12,7 +12,7 @@ import {
   type OpencodeClient as OpencodeClientV2,
 } from '@opencode-ai/sdk/v2'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import {
   DirectoryNotAccessibleError,
   ServerStartError,
@@ -21,7 +21,7 @@ import {
   type OpenCodeErrors,
 } from './errors.js'
 
-const opencodeLogger = createLogger('OPENCODE')
+const opencodeLogger = createLogger(LogPrefix.OPENCODE)
 
 const opencodeServers = new Map<
   string,
@@ -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

@@ -24,7 +24,7 @@ import {
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage, type WorktreeInfo } from './system-message.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { isAbortError } from './utils.js'
 import {
   showAskUserQuestionDropdowns,
@@ -38,9 +38,9 @@ import {
 } from './commands/permissions.js'
 import * as errore from 'errore'
 
-const sessionLogger = createLogger('SESSION')
-const voiceLogger = createLogger('VOICE')
-const discordLogger = createLogger('DISCORD')
+const sessionLogger = createLogger(LogPrefix.SESSION)
+const voiceLogger = createLogger(LogPrefix.VOICE)
+const discordLogger = createLogger(LogPrefix.DISCORD)
 
 export const abortControllers = new Map<string, AbortController>()
 
@@ -134,7 +134,8 @@ 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
-  controller.abort('model-change')
+  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
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
@@ -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)
     }
   }
 
@@ -350,10 +354,10 @@ export async function handleOpencodeSession({
     }
   }
 
-  // Cancel any pending question tool if user sends a new message (silently, no thread message)
-  const questionCancelled = await cancelPendingQuestion(thread.id)
-  if (questionCancelled) {
-    sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`)
+  // Answer any pending question tool with the user's message (silently, no thread message)
+  const questionAnswered = await cancelPendingQuestion(thread.id, prompt)
+  if (questionAnswered) {
+    sessionLogger.log(`[QUESTION] Answered pending question with user message`)
   }
 
   const abortController = new AbortController()
@@ -418,11 +422,15 @@ export async function handleOpencodeSession({
   let usedAgent: string | undefined
   let tokensUsedInSession = 0
   let lastDisplayedContextPercentage = 0
+  let lastRateLimitDisplayTime = 0
   let modelContextLimit: number | undefined
   let assistantMessageId: string | undefined
   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) {
@@ -469,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
     }
 
@@ -496,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()
@@ -587,6 +598,7 @@ export async function handleOpencodeSession({
       if (msg.sessionID !== session.id) {
         return
       }
+      hasReceivedEvent = true
 
       if (msg.role !== 'assistant') {
         return
@@ -686,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')
             }
@@ -696,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
@@ -750,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') {
@@ -836,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
@@ -882,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) {
@@ -894,6 +913,7 @@ export async function handleOpencodeSession({
         thread,
         permission,
         directory,
+        subtaskLabel,
       })
 
       if (!pendingPermissions.has(thread.id)) {
@@ -917,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
       }
 
@@ -988,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,
@@ -1011,10 +1035,51 @@ export async function handleOpencodeSession({
       })
     }
 
+    const handleSessionStatus = async (properties: {
+      sessionID: string
+      status: { type: 'idle' } | { type: 'retry'; attempt: number; message: string; next: number } | { type: 'busy' }
+    }) => {
+      if (properties.sessionID !== session.id) {
+        return
+      }
+      if (properties.status.type !== 'retry') {
+        return
+      }
+      // Throttle to once per 10 seconds
+      const now = Date.now()
+      if (now - lastRateLimitDisplayTime < 10_000) {
+        return
+      }
+      lastRateLimitDisplayTime = now
+
+      const { attempt, message, next } = properties.status
+      const remainingMs = Math.max(0, next - now)
+      const remainingSec = Math.ceil(remainingMs / 1000)
+
+      const duration = (() => {
+        if (remainingSec < 60) {
+          return `${remainingSec}s`
+        }
+        const mins = Math.floor(remainingSec / 60)
+        const secs = remainingSec % 60
+        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`
+      })()
+
+      const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`
+      await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+    }
+
     const handleSessionIdle = (idleSessionId: string) => {
       if (idleSessionId === session.id) {
-        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
-        abortController.abort('finished')
+        if (!promptResolved || !hasReceivedEvent) {
+          sessionLogger.log(
+            `[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, 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
       }
 
@@ -1051,6 +1116,9 @@ export async function handleOpencodeSession({
           case 'session.idle':
             handleSessionIdle(event.properties.sessionID)
             break
+          case 'session.status':
+            await handleSessionStatus(event.properties)
+            break
           default:
             break
         }
@@ -1079,7 +1147,8 @@ export async function handleOpencodeSession({
         stopTyping = null
       }
 
-      if (!abortController.signal.aborted || abortController.signal.reason === 'finished') {
+      const abortReason = (abortController.signal.reason as Error)?.message
+      if (!abortController.signal.aborted || abortReason === 'finished') {
         const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime)
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
@@ -1155,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,
@@ -1170,7 +1240,7 @@ export async function handleOpencodeSession({
         }
       } else {
         sessionLogger.log(
-          `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
+          `Session was aborted (reason: ${abortReason}), skipping duration message`,
         )
       }
     }
@@ -1250,6 +1320,8 @@ export async function handleOpencodeSession({
           }
         : undefined
 
+    hasSentParts = false
+
     const response = command
       ? await getClient().session.command({
           path: { id: session.id },
@@ -1289,7 +1361,7 @@ export async function handleOpencodeSession({
       throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`)
     }
 
-    abortController.abort('finished')
+    promptResolved = true
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
@@ -1325,7 +1397,8 @@ export async function handleOpencodeSession({
   }
 
   sessionLogger.error(`ERROR: Failed to send prompt:`, promptError)
-  abortController.abort('error')
+  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) {
     const reactionResult = await errore.tryAsync(async () => {

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

@@ -12,10 +12,10 @@ import {
   type AssistantMessage,
   type Provider,
 } from '@opencode-ai/sdk'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import * as errore from 'errore'
 
-const toolsLogger = createLogger('TOOLS')
+const toolsLogger = createLogger(LogPrefix.TOOLS)
 
 import { ShareMarkdown } from './markdown.js'
 import { formatDistanceToNow } from './utils.js'
@@ -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')

package/src/voice-handler.ts

@@ -37,9 +37,9 @@ import {
 import { transcribeAudio } from './voice.js'
 import { FetchError } from './errors.js'
 
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const voiceLogger = createLogger('VOICE')
+const voiceLogger = createLogger(LogPrefix.VOICE)
 
 export type VoiceConnectionData = {
   connection: VoiceConnection

package/src/voice.ts

@@ -5,7 +5,7 @@
 
 import { GoogleGenAI, Type, type Content, type Part, type Tool } from '@google/genai'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { glob } from 'glob'
 import { ripGrep } from 'ripgrep-js'
 import {
@@ -19,7 +19,7 @@ import {
   GlobSearchError,
 } from './errors.js'
 
-const voiceLogger = createLogger('VOICE')
+const voiceLogger = createLogger(LogPrefix.VOICE)
 
 export type TranscriptionToolRunner = ({
   name,