kimaki 0.4.46 → 0.4.48

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
   )
 }
 
@@ -337,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,
@@ -345,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/config.ts

@@ -44,6 +44,20 @@ export function getProjectsDir(): string {
   return path.join(getDataDir(), 'projects')
 }
 
+// Default verbosity for channels that haven't set a per-channel override.
+// Set via --verbosity CLI flag at startup.
+import type { VerbosityLevel } from './database.js'
+
+let defaultVerbosity: VerbosityLevel = 'tools-and-text'
+
+export function getDefaultVerbosity(): VerbosityLevel {
+  return defaultVerbosity
+}
+
+export function setDefaultVerbosity(level: VerbosityLevel): void {
+  defaultVerbosity = level
+}
+
 const DEFAULT_LOCK_PORT = 29988
 
 /**

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 { getDataDir } from './config.js'
+import { createLogger, LogPrefix } from './logger.js'
+import { getDataDir, getDefaultVerbosity } from './config.js'
 
-const dbLogger = createLogger('DB')
+const dbLogger = createLogger(LogPrefix.DB)
 
 let db: Database.Database | null = null
 
@@ -69,8 +69,11 @@ export function getDatabase(): Database.Database {
     // Migration: add app_id column to channel_directories for multi-bot support
     try {
       db.exec(`ALTER TABLE channel_directories ADD COLUMN app_id TEXT`)
-    } catch {
-      // Column already exists, ignore
+    } catch (error) {
+      dbLogger.debug(
+        'Failed to add app_id column to channel_directories (likely exists):',
+        error instanceof Error ? error.message : String(error),
+      )
     }
 
     // Table for threads that should auto-start a session (created by CLI without --notify-only)
@@ -378,14 +381,17 @@ export function runVerbosityMigrations(database?: Database.Database): void {
 
 /**
  * Get the verbosity setting for a channel.
- * @returns 'tools-and-text' (default) or 'text-only'
+ * Falls back to the global default set via --verbosity CLI flag if no per-channel override exists.
  */
 export function getChannelVerbosity(channelId: string): VerbosityLevel {
   const db = getDatabase()
   const row = db
     .prepare('SELECT verbosity FROM channel_verbosity WHERE channel_id = ?')
     .get(channelId) as { verbosity: string } | undefined
-  return (row?.verbosity as VerbosityLevel) || 'tools-and-text'
+  if (row?.verbosity) {
+    return row.verbosity as VerbosityLevel
+  }
+  return getDefaultVerbosity()
 }
 
 /**

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,12 @@ 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)
+
+function prefixWithDiscordUser({ username, prompt }: { username: string; prompt: string }): string {
+  return `<discord-user name="${username}" />\n${prompt}`
+}
 
 type StartOptions = {
   token: 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/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,81 @@ 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.
+ */
+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 +245,23 @@ export function getToolSummaryText(part: Part): string {
       : `(+${added}-${removed})`
   }
 
+  if (part.tool === 'apply_patch') {
+    // 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 ''
+    }
+    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') {
     const filePath = (part.state.input?.filePath as string) || ''
     const content = (part.state.input?.content as string) || ''
@@ -228,7 +320,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 +352,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 +436,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)