kimaki 0.4.46 → 0.4.47

package/src/database.ts

@@ -6,10 +6,10 @@ import Database from 'better-sqlite3'
 import fs from 'node:fs'
 import path from 'node:path'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { getDataDir } from './config.js'
 
-const dbLogger = createLogger('DB')
+const dbLogger = createLogger(LogPrefix.DB)
 
 let db: Database.Database | null = null
 

package/src/discord-bot.ts

@@ -66,7 +66,7 @@ import {
 } from 'discord.js'
 import fs from 'node:fs'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { setGlobalDispatcher, Agent } from 'undici'
 
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
@@ -74,8 +74,8 @@ import { setGlobalDispatcher, Agent } from 'undici'
 // regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }))
 
-const discordLogger = createLogger('DISCORD')
-const voiceLogger = createLogger('VOICE')
+const discordLogger = createLogger(LogPrefix.DISCORD)
+const voiceLogger = createLogger(LogPrefix.VOICE)
 
 type StartOptions = {
   token: string

package/src/discord-utils.ts

@@ -8,12 +8,12 @@ import { formatMarkdownTables } from './format-tables.js'
 import { getChannelDirectory } from './database.js'
 import { limitHeadingDepth } from './limit-heading-depth.js'
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import mime from 'mime'
 import fs from 'node:fs'
 import path from 'node:path'
 
-const discordLogger = createLogger('DISCORD')
+const discordLogger = createLogger(LogPrefix.DISCORD)
 
 export const SILENT_MESSAGE_FLAGS = 4 | 4096
 // Same as SILENT but without SuppressNotifications - triggers badge/notification

package/src/genai-worker-wrapper.ts

@@ -5,10 +5,10 @@
 import { Worker } from 'node:worker_threads'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
 import type { Tool as AITool } from 'ai'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const genaiWorkerLogger = createLogger('GENAI WORKER')
-const genaiWrapperLogger = createLogger('GENAI WORKER WRAPPER')
+const genaiWorkerLogger = createLogger(LogPrefix.GENAI_WORKER)
+const genaiWrapperLogger = createLogger(LogPrefix.GENAI_WORKER)
 
 export interface GenAIWorkerOptions {
   directory: string

package/src/genai-worker.ts

@@ -13,13 +13,13 @@ import type { Session } from '@google/genai'
 import { getTools } from './tools.js'
 import { mkdir } from 'node:fs/promises'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
 if (!parentPort) {
   throw new Error('This module must be run as a worker thread')
 }
 
-const workerLogger = createLogger(`WORKER ${threadId}`)
+const workerLogger = createLogger(`${LogPrefix.WORKER}_${threadId}`)
 workerLogger.log('GenAI worker started')
 
 // Define sendError early so it can be used by global handlers

package/src/genai.ts

@@ -7,10 +7,10 @@ import type { CallableTool } from '@google/genai'
 import { writeFile } from 'fs'
 import type { Tool as AITool } from 'ai'
 
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { aiToolToCallableTool } from './ai-tool-to-genai.js'
 
-const genaiLogger = createLogger('GENAI')
+const genaiLogger = createLogger(LogPrefix.GENAI)
 
 const audioParts: Buffer[] = []
 

package/src/interaction-handler.ts

@@ -19,6 +19,7 @@ import {
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js'
 import { handlePermissionSelectMenu } from './commands/permissions.js'
 import { handleAbortCommand } from './commands/abort.js'
+import { handleCompactCommand } from './commands/compact.js'
 import { handleShareCommand } from './commands/share.js'
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js'
 import {
@@ -32,9 +33,9 @@ import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
 import { handleUserCommand } from './commands/user-command.js'
 import { handleVerbosityCommand } from './commands/verbosity.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const interactionLogger = createLogger('INTERACTION')
+const interactionLogger = createLogger(LogPrefix.INTERACTION)
 
 export function registerInteractionHandler({
   discordClient,
@@ -126,6 +127,10 @@ export function registerInteractionHandler({
             await handleAbortCommand({ command: interaction, appId })
             return
 
+          case 'compact':
+            await handleCompactCommand({ command: interaction, appId })
+            return
+
           case 'share':
             await handleShareCommand({ command: interaction, appId })
             return

package/src/logger.ts

@@ -1,12 +1,54 @@
-// Prefixed logging utility using @clack/prompts.
-// Creates loggers with consistent prefixes for different subsystems
-// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
+// Prefixed logging utility.
+// Uses picocolors for compact frequent logs (log, info, debug).
+// Uses @clack/prompts only for important events (warn, error) with visual distinction.
 
-import { log } from '@clack/prompts'
+import { log as clackLog } from '@clack/prompts'
 import fs from 'node:fs'
 import path, { dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import util from 'node:util'
+import pc from 'picocolors'
+
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+  ABORT: 'ABORT',
+  ADD_PROJECT: 'ADD_PROJ',
+  AGENT: 'AGENT',
+  ASK_QUESTION: 'QUESTION',
+  CLI: 'CLI',
+  COMPACT: 'COMPACT',
+  CREATE_PROJECT: 'NEW_PROJ',
+  DB: 'DB',
+  DISCORD: 'DISCORD',
+  FORK: 'FORK',
+  FORMATTING: 'FORMAT',
+  GENAI: 'GENAI',
+  GENAI_WORKER: 'GENAI_W',
+  INTERACTION: 'INTERACT',
+  MARKDOWN: 'MARKDOWN',
+  MODEL: 'MODEL',
+  OPENAI: 'OPENAI',
+  OPENCODE: 'OPENCODE',
+  PERMISSIONS: 'PERMS',
+  QUEUE: 'QUEUE',
+  REMOVE_PROJECT: 'RM_PROJ',
+  RESUME: 'RESUME',
+  SESSION: 'SESSION',
+  SHARE: 'SHARE',
+  TOOLS: 'TOOLS',
+  UNDO_REDO: 'UNDO',
+  USER_CMD: 'USER_CMD',
+  VERBOSITY: 'VERBOSE',
+  VOICE: 'VOICE',
+  WORKER: 'WORKER',
+  WORKTREE: 'WORKTREE',
+  XML: 'XML',
+} as const
+
+export type LogPrefixType = (typeof LogPrefix)[keyof typeof LogPrefix]
+
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length))
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -39,27 +81,39 @@ function writeToFile(level: string, prefix: string, args: unknown[]) {
   fs.appendFileSync(logFilePath, message)
 }
 
-export function createLogger(prefix: string) {
+function getTimestamp(): string {
+  const now = new Date()
+  return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`
+}
+
+function padPrefix(prefix: string): string {
+  return prefix.padEnd(MAX_PREFIX_LENGTH)
+}
+
+export function createLogger(prefix: LogPrefixType | string) {
+  const paddedPrefix = padPrefix(prefix)
   return {
     log: (...args: unknown[]) => {
       writeToFile('INFO', prefix, args)
-      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
+      console.log(pc.dim(getTimestamp()), pc.cyan(paddedPrefix), ...args.map(formatArg))
     },
     error: (...args: unknown[]) => {
       writeToFile('ERROR', prefix, args)
-      log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '))
+      // use clack for errors - visually distinct
+      clackLog.error([paddedPrefix, ...args.map(formatArg)].join(' '))
     },
     warn: (...args: unknown[]) => {
       writeToFile('WARN', prefix, args)
-      log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '))
+      // use clack for warnings - visually distinct
+      clackLog.warn([paddedPrefix, ...args.map(formatArg)].join(' '))
     },
     info: (...args: unknown[]) => {
       writeToFile('INFO', prefix, args)
-      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
+      console.log(pc.dim(getTimestamp()), pc.blue(paddedPrefix), ...args.map(formatArg))
     },
     debug: (...args: unknown[]) => {
       writeToFile('DEBUG', prefix, args)
-      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
+      console.log(pc.dim(getTimestamp()), pc.dim(paddedPrefix), ...args.map(formatArg))
     },
   }
 }

package/src/markdown.ts

@@ -9,7 +9,7 @@ import { createTaggedError } from 'errore'
 import * as yaml from 'js-yaml'
 import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js'
 
 // Generic error for unexpected exceptions in async operations
@@ -18,7 +18,7 @@ class UnexpectedError extends createTaggedError({
   message: '$message',
 }) {}
 
-const markdownLogger = createLogger('MARKDOWN')
+const markdownLogger = createLogger(LogPrefix.MARKDOWN)
 
 export class ShareMarkdown {
   constructor(private client: OpencodeClient) {}

package/src/message-formatting.ts

@@ -8,7 +8,7 @@ import type { Message } from 'discord.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { FetchError } from './errors.js'
 
 // Generic message type compatible with both v1 and v2 SDK
@@ -19,7 +19,7 @@ type GenericSessionMessage = {
 
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments')
 
-const logger = createLogger('FORMATTING')
+const logger = createLogger(LogPrefix.FORMATTING)
 
 /**
  * Escapes Discord inline markdown characters so dynamic content
@@ -29,6 +29,13 @@ function escapeInlineMarkdown(text: string): string {
   return text.replace(/([*_~|`\\])/g, '\\$1')
 }
 
+/**
+ * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
+ */
+function normalizeWhitespace(text: string): string {
+  return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ')
+}
+
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -170,6 +177,73 @@ export function getToolSummaryText(part: Part): string {
       : `(+${added}-${removed})`
   }
 
+  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
+        }
+      }
+    }
+
+    return ''
+  }
+
   if (part.tool === 'write') {
     const filePath = (part.state.input?.filePath as string) || ''
     const content = (part.state.input?.content as string) || ''
@@ -228,7 +302,8 @@ export function getToolSummaryText(part: Part): string {
     .map(([key, value]) => {
       if (value === null || value === undefined) return null
       const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
-      const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue
+      const normalized = normalizeWhitespace(stringValue)
+      const truncatedValue = normalized.length > 50 ? normalized.slice(0, 50) + '…' : normalized
       return `${key}: ${truncatedValue}`
     })
     .filter(Boolean)
@@ -259,7 +334,7 @@ export function formatTodoList(part: Part): string {
 }
 
 export function formatPart(part: Part, prefix?: string): string {
-  const pfx = prefix ? `${prefix}: ` : ''
+  const pfx = prefix ? `${prefix} ⋅ ` : ''
 
   if (part.type === 'text') {
     if (!part.text?.trim()) return ''
@@ -343,12 +418,13 @@ export function formatPart(part: Part, prefix?: string): string {
       if (part.state.status === 'error') {
         return '⨯'
       }
-      if (part.tool === 'edit' || part.tool === 'write') {
+      if (part.tool === 'edit' || part.tool === 'write' || part.tool === 'apply_patch') {
         return '◼︎'
       }
       return '┣'
     })()
-    return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim()
+    const toolParts = [part.tool, toolTitle, summaryText].filter(Boolean).join(' ')
+    return `${icon} ${pfx}${toolParts}`
   }
 
   logger.warn('Unknown part type:', part)

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,

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,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
-  controller.abort('model-change')
+  controller.abort(new Error('model-change'))
 
   // Also call the API abort endpoint
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
@@ -350,10 +350,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,6 +418,7 @@ 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
@@ -1011,10 +1012,53 @@ 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) {
+        // 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) {
+          sessionLogger.log(
+            `[SESSION IDLE] Ignoring stale idle event for ${session.id} (no content received yet)`,
+          )
+          return
+        }
         sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
-        abortController.abort('finished')
+        abortController.abort(new Error('finished'))
         return
       }
 
@@ -1051,6 +1095,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 +1126,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}` : ''
@@ -1170,7 +1218,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`,
         )
       }
     }
@@ -1289,7 +1337,7 @@ export async function handleOpencodeSession({
       throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`)
     }
 
-    abortController.abort('finished')
+    abortController.abort(new Error('finished'))
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
@@ -1325,7 +1373,7 @@ export async function handleOpencodeSession({
   }
 
   sessionLogger.error(`ERROR: Failed to send prompt:`, promptError)
-  abortController.abort('error')
+  abortController.abort(new Error('error'))
 
   if (originalMessage) {
     const reactionResult = await errore.tryAsync(async () => {

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'

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,