kimaki 0.4.45 → 0.4.47

package/src/commands/share.ts

@@ -5,10 +5,10 @@ import type { CommandContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('SHARE')
+const logger = createLogger(LogPrefix.SHARE)
 
 export async function handleShareCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel

package/src/commands/undo-redo.ts

@@ -5,10 +5,10 @@ import type { CommandContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('UNDO-REDO')
+const logger = createLogger(LogPrefix.UNDO_REDO)
 
 export async function handleUndoCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel

package/src/commands/user-command.ts

@@ -5,11 +5,11 @@ import type { CommandContext, CommandHandler } from './types.js'
 import { ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { getDatabase, getChannelDirectory } from '../database.js'
 import fs from 'node:fs'
 
-const userCommandLogger = createLogger('USER_CMD')
+const userCommandLogger = createLogger(LogPrefix.USER_CMD)
 
 export const handleUserCommand: CommandHandler = async ({ command, appId }: CommandContext) => {
   const discordCommandName = command.commandName
@@ -136,6 +136,9 @@ export const handleUserCommand: CommandHandler = async ({ command, appId }: Comm
         reason: `OpenCode command: ${commandName}`,
       })
 
+      // Add user to thread so it appears in their sidebar
+      await newThread.members.add(command.user.id)
+
       await command.editReply(`Started /${commandName} in ${newThread.toString()}`)
 
       await handleOpencodeSession({

package/src/commands/verbosity.ts

@@ -5,9 +5,9 @@
 
 import { ChatInputCommandInteraction, ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
 import { getChannelVerbosity, setChannelVerbosity, type VerbosityLevel } from '../database.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const verbosityLogger = createLogger('VERBOSITY')
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY)
 
 /**
  * Handle the /verbosity slash command.
@@ -65,7 +65,7 @@ export async function handleVerbosityCommand({
     : 'All output will be shown, including tool executions and status messages.'
 
   await command.reply({
-    content: `Verbosity set to **${level}**.\n\n${description}\n\nThis applies to all new sessions in this channel.`,
+    content: `Verbosity set to **${level}**.\n${description}\nThis applies to all new sessions in this channel.`,
     ephemeral: true,
   })
 }

package/src/commands/worktree-settings.ts

@@ -5,9 +5,9 @@
 import { ChatInputCommandInteraction, ChannelType, type TextChannel } from 'discord.js'
 import { getChannelWorktreesEnabled, setChannelWorktreesEnabled } from '../database.js'
 import { getKimakiMetadata } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const worktreeSettingsLogger = createLogger('WORKTREE_SETTINGS')
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE)
 
 /**
  * Handle the /enable-worktrees slash command.

package/src/commands/worktree.ts

@@ -14,12 +14,12 @@ import {
 } from '../database.js'
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
-import { createWorktreeWithSubmodules } from '../worktree-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { createWorktreeWithSubmodules, captureGitDiff, type CapturedDiff } from '../worktree-utils.js'
 import { WORKTREE_PREFIX } from './merge-worktree.js'
 import * as errore from 'errore'
 
-const logger = createLogger('WORKTREE')
+const logger = createLogger(LogPrefix.WORKTREE)
 
 class WorktreeError extends Error {
   constructor(message: string, options?: { cause?: unknown }) {
@@ -91,6 +91,7 @@ function getProjectDirectoryFromChannel(
 
 /**
  * Create worktree in background and update starter message when done.
+ * If diff is provided, it's applied during worktree creation (before submodule init).
  */
 async function createWorktreeInBackground({
   thread,
@@ -98,19 +99,22 @@ async function createWorktreeInBackground({
   worktreeName,
   projectDirectory,
   clientV2,
+  diff,
 }: {
   thread: ThreadChannel
   starterMessage: Message
   worktreeName: string
   projectDirectory: string
   clientV2: ReturnType<typeof getOpencodeClientV2> & {}
+  diff?: CapturedDiff | null
 }): Promise<void> {
-  // Create worktree using SDK v2 and init submodules
+  // Create worktree using SDK v2, apply diff, then init submodules
   logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`)
   const worktreeResult = await createWorktreeWithSubmodules({
     clientV2,
     directory: projectDirectory,
     name: worktreeName,
+    diff,
   })
 
   if (worktreeResult instanceof Error) {
@@ -123,10 +127,12 @@ async function createWorktreeInBackground({
 
   // Success - update database and edit starter message
   setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory })
+  const diffStatus = diff ? (worktreeResult.diffApplied ? '\n✅ Changes applied' : '\n⚠️ Failed to apply changes') : ''
   await starterMessage.edit(
     `🌳 **Worktree: ${worktreeName}**\n` +
     `📁 \`${worktreeResult.directory}\`\n` +
-    `🌿 Branch: \`${worktreeResult.branch}\``
+    `🌿 Branch: \`${worktreeResult.branch}\`` +
+    diffStatus
   )
 }
 
@@ -228,6 +234,9 @@ export async function handleNewWorktreeCommand({
         reason: 'Worktree session',
       })
 
+      // Add user to thread so it appears in their sidebar
+      await thread.members.add(command.user.id)
+
       return { thread, starterMessage }
     },
     catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
@@ -334,6 +343,11 @@ async function handleWorktreeInThread({
     return
   }
 
+  // Capture git diff from project directory before creating worktree.
+  // This allows transferring uncommitted changes to the new worktree.
+  const diff = await captureGitDiff(projectDirectory)
+  const hasDiff = diff && (diff.staged || diff.unstaged)
+
   // Store pending worktree in database for this existing thread
   createPendingWorktree({
     threadId: thread.id,
@@ -342,20 +356,22 @@ async function handleWorktreeInThread({
   })
 
   // Send status message in thread
+  const diffNote = hasDiff ? '\n📋 Will transfer uncommitted changes' : ''
   const statusMessage = await thread.send({
-    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...${diffNote}`,
     flags: SILENT_MESSAGE_FLAGS,
   })
 
   await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`)
 
-  // Create worktree in background
+  // Create worktree in background, passing diff to apply after creation
   createWorktreeInBackground({
     thread,
     starterMessage: statusMessage,
     worktreeName,
     projectDirectory,
     clientV2,
+    diff,
   }).catch((e) => {
     logger.error('[NEW-WORKTREE] Background error:', e)
   })

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
@@ -425,6 +425,9 @@ export async function startDiscordBot({
           reason: 'Start Claude session',
         })
 
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(message.author.id)
+
         discordLogger.log(`Created thread "${thread.name}" (${thread.id})`)
 
         // Create worktree if worktrees are enabled (CLI flag OR channel setting)

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,