kimaki 0.18.0 → 0.20.0

package/src/markdown.ts

@@ -32,8 +32,10 @@ export class ShareMarkdown {
     sessionID: string
     includeSystemInfo?: boolean
     lastAssistantOnly?: boolean
+    /** When true (default), tool calls show a compact one-liner with line count instead of full output. */
+    compactTools?: boolean
   }): Promise<SessionNotFoundError | MessagesNotFoundError | string> {
-    const { sessionID, includeSystemInfo, lastAssistantOnly } = options
+    const { sessionID, includeSystemInfo, lastAssistantOnly, compactTools = true } = options
 
     // Get session info
     const sessionResponse = await this.client.session.get({
@@ -96,7 +98,7 @@ export class ShareMarkdown {
     }
 
     for (const message of messagesToRender) {
-      const messageLines = this.renderMessage(message!.info, message!.parts)
+      const messageLines = this.renderMessage(message!.info, message!.parts, { compactTools })
       lines.push(...messageLines)
       lines.push('')
     }
@@ -104,7 +106,7 @@ export class ShareMarkdown {
     return lines.join('\n')
   }
 
-  private renderMessage(message: any, parts: any[]): string[] {
+  private renderMessage(message: any, parts: any[], opts: { compactTools: boolean }): string[] {
     const lines: string[] = []
 
     if (message.role === 'user') {
@@ -148,7 +150,9 @@ export class ShareMarkdown {
       })
 
       for (const part of filteredParts) {
-        const partLines = this.renderPart(part, message)
+        const partLines = opts.compactTools
+          ? this.renderPartCompact(part, message)
+          : this.renderPart(part, message)
         lines.push(...partLines)
       }
 
@@ -251,6 +255,61 @@ export class ShareMarkdown {
     return lines
   }
 
+  /** Compact rendering: tool calls become a single line with line count instead of full output. */
+  private renderPartCompact(part: any, message: any): string[] {
+    // Non-tool parts render the same as verbose
+    if (part.type !== 'tool') {
+      return this.renderPart(part, message)
+    }
+
+    const lines: string[] = []
+
+    if (part.state.status === 'completed') {
+      const output: string = part.state.output || ''
+      const lineCount = output ? output.split('\n').length : 0
+      const inputSummary = this.compactInputSummary(part.state.input)
+      const outputLabel = lineCount > 0 ? `(${lineCount} lines)` : ''
+      const parts = [inputSummary, outputLabel].filter(Boolean).join(' ')
+      lines.push(`> 🛠️ **${part.tool}**${parts ? ` ${parts}` : ''}`)
+      lines.push('')
+    } else if (part.state.status === 'error') {
+      const errorText = (part.state.error || 'Unknown error').split('\n')[0].slice(0, 120)
+      lines.push(`> ❌ **${part.tool}** — ${errorText}`)
+      lines.push('')
+    }
+
+    return lines
+  }
+
+  /** Build a compact key=value summary of tool input, max 2 params, 80 chars each. */
+  private compactInputSummary(input: Record<string, unknown> | undefined): string {
+    if (!input) return ''
+    const entries = Object.entries(input)
+    if (entries.length === 0) return ''
+
+    const parts: string[] = []
+    const maxParams = 2
+    for (let i = 0; i < Math.min(entries.length, maxParams); i++) {
+      const [key, value] = entries[i]!
+      let val: string
+      try {
+        val = typeof value === 'string'
+          ? value
+          : (JSON.stringify(value) ?? String(value))
+      } catch {
+        val = String(value)
+      }
+      // Collapse whitespace for readability
+      const collapsed = val.replace(/\s+/g, ' ').trim()
+      const normalized = collapsed.length > 80 ? `${collapsed.slice(0, 80)}…` : collapsed
+      parts.push(`${key}=${normalized}`)
+    }
+    if (entries.length > maxParams) {
+      parts.push('...')
+    }
+    return parts.join(', ')
+  }
+
   private formatDuration(ms: number): string {
     if (ms < 1000) return `${ms}ms`
     if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`

package/src/message-formatting.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'vitest'
-import { formatPart, formatTodoList, serializeEmbeds, serializePoll, serializeMessageSnapshots } from './message-formatting.js'
+import { formatBashToolTitle, formatPart, formatTodoList, serializeEmbeds, serializePoll, serializeMessageSnapshots } from './message-formatting.js'
 import type { Collection, Embed, Message, MessageSnapshot, Poll } from 'discord.js'
 import type { Part } from '@opencode-ai/sdk/v2'
 
@@ -48,6 +48,65 @@ describe('formatPart', () => {
   })
 })
 
+describe('formatBashToolTitle', () => {
+  test('short single-line command shown in full', () => {
+    expect(formatBashToolTitle({ command: 'echo hello' })).toMatchInlineSnapshot(`" _echo hello_"`)
+  })
+
+  test('multiline command without description truncates to first line', () => {
+    expect(
+      formatBashToolTitle({ command: 'echo hello\necho world\necho done' }),
+    ).toMatchInlineSnapshot(`" _echo hello_"`)
+  })
+
+  test('long single-line command is truncated with ellipsis', () => {
+    const longCommand = 'a'.repeat(150)
+    const result = formatBashToolTitle({ command: longCommand })
+    expect(result).toContain('…')
+    expect(result.length).toBeLessThan(150)
+  })
+
+  test('description is preferred over truncated command when present', () => {
+    expect(
+      formatBashToolTitle({
+        command: 'echo hello\necho world',
+        description: 'Print greeting',
+      }),
+    ).toMatchInlineSnapshot(`" _Print greeting_"`)
+  })
+
+  test('stateTitle used as last resort', () => {
+    expect(
+      formatBashToolTitle({ command: '', stateTitle: 'Running tests' }),
+    ).toMatchInlineSnapshot(`" _Running tests_"`)
+  })
+
+  test('empty inputs return empty string', () => {
+    expect(formatBashToolTitle({ command: '' })).toBe('')
+  })
+
+  test('leading blank line skipped, uses first meaningful line', () => {
+    expect(
+      formatBashToolTitle({ command: '\npnpm test\npnpm build' }),
+    ).toMatchInlineSnapshot(`" _pnpm test_"`)
+  })
+
+  test('whitespace-only first line skipped', () => {
+    expect(
+      formatBashToolTitle({ command: '   \npnpm test' }),
+    ).toMatchInlineSnapshot(`" _pnpm test_"`)
+  })
+
+  test('no description field (new opencode) with multiline command', () => {
+    // This is the exact scenario that was broken: opencode removed `description`
+    // from the bash tool schema, so multiline commands rendered as just "┣ bash"
+    const command = 'git diff HEAD~1 --stat && git log --oneline -5'
+    expect(formatBashToolTitle({ command: command + '\n' + 'echo done' })).toMatchInlineSnapshot(
+      `" _git diff HEAD\\~1 --stat && git log --oneline -5_"`,
+    )
+  })
+})
+
 describe('formatTodoList', () => {
   test('formats active todo with monospace numbers', () => {
     const part: Part = {

package/src/message-formatting.ts

@@ -350,6 +350,54 @@ export async function getFileAttachments(
 
 const MAX_BASH_COMMAND_INLINE_LENGTH = 100
 
+/**
+ * Format the inline title for a bash tool part. Handles three cases:
+ * 1. Short single-line command → show full command
+ * 2. Long/multiline command with description → show description
+ * 3. Long/multiline command without description → truncate first line of command
+ *
+ * The description field was removed from the bash tool schema in newer opencode
+ * versions, so case 3 is the common path now. Without this fallback, long commands
+ * would render as just "┣ bash" with no context.
+ */
+export function formatBashToolTitle({
+  command,
+  description,
+  stateTitle,
+}: {
+  command: string
+  description?: string
+  stateTitle?: string
+}): string {
+  if (!command && !description && !stateTitle) return ''
+
+  const isSingleLine = !command.includes('\n')
+  // Find first non-empty line to handle commands with leading blank lines
+  const firstMeaningfulLine =
+    command
+      .split('\n')
+      .find((line) => line.trim().length > 0)
+      ?.trimStart() ?? ''
+
+  if (command && isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH) {
+    return ` _${escapeInlineMarkdown(command)}_`
+  }
+  if (description) {
+    return ` _${escapeInlineMarkdown(description)}_`
+  }
+  if (firstMeaningfulLine.length > 0) {
+    const truncated =
+      firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH
+        ? firstMeaningfulLine.slice(0, MAX_BASH_COMMAND_INLINE_LENGTH) + '…'
+        : firstMeaningfulLine
+    return ` _${escapeInlineMarkdown(truncated)}_`
+  }
+  if (stateTitle) {
+    return ` _${escapeInlineMarkdown(stateTitle)}_`
+  }
+  return ''
+}
+
 export function getToolSummaryText(part: Part): string {
   if (part.type !== 'tool') return ''
 
@@ -568,13 +616,10 @@ export function formatPart(part: Part, prefix?: string): string {
       }
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
-      const isSingleLine = !command.includes('\n')
-      const toolTitle =
-        isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH
-          ? ` _${escapeInlineMarkdown(command)}_`
-          : description
-            ? ` _${escapeInlineMarkdown(description)}_`
-            : ''
+      const toolTitle = formatBashToolTitle({
+        command,
+        description,
+      })
       return `┣ ${pfx}bash${toolTitle}`
     }
 
@@ -587,14 +632,12 @@ export function formatPart(part: Part, prefix?: string): string {
     } else if (part.tool === 'bash') {
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
-      const isSingleLine = !command.includes('\n')
-      if (isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH) {
-        toolTitle = `_${escapeInlineMarkdown(command)}_`
-      } else if (description) {
-        toolTitle = `_${escapeInlineMarkdown(description)}_`
-      } else if (stateTitle) {
-        toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
-      }
+      const formatted = formatBashToolTitle({
+        command,
+        description,
+        stateTitle,
+      })
+      toolTitle = formatted.startsWith(' ') ? formatted.slice(1) : formatted
     } else if (stateTitle) {
       toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
     }

package/src/session-handler/thread-session-runtime.ts

@@ -365,23 +365,24 @@ function getTokenTotal(tokens: TokenUsage): number {
   )
 }
 
+/**
+ * Built-in read-only tools that are hidden in default verbosity mode.
+ * Any tool NOT in this list is considered "essential" and shown,
+ * which means custom tools, MCP tools, and plugin tools are visible by default.
+ */
+const HIDDEN_READONLY_TOOLS = [
+  'read',
+  'glob',
+  'grep',
+  'describe-media',
+  'todoread',
+]
+
 /** Check if a tool part is "essential" (shown in text-and-essential-tools mode). */
 export function isEssentialToolName(toolName: string): boolean {
-  const essentialTools = [
-    'edit',
-    'write',
-    'apply_patch',
-    'bash',
-    'webfetch',
-    'websearch',
-    'googlesearch',
-    'codesearch',
-    'task',
-    'todowrite',
-    'skill',
-  ]
-  // Also match any MCP tool that contains these names
-  return essentialTools.some((name) => {
+  // Hide known read-only built-in tools; show everything else
+  // (custom tools, MCP tools, plugin tools are visible by default)
+  return !HIDDEN_READONLY_TOOLS.some((name) => {
     return toolName === name || toolName.endsWith(`_${name}`)
   })
 }
@@ -559,6 +560,13 @@ export type IngressInput = {
   sessionStartSource?: { scheduleKind: 'at' | 'cron'; scheduledTaskId?: number }
   /** Optional guard for retries: skip enqueue when session has changed. */
   expectedSessionId?: string
+  /**
+   * When true, the message is added to the session context without triggering
+   * the AI agent loop. Used for messages that should be visible to the model
+   * on the next real turn but should not cause a response on their own
+   * (e.g. user-to-user replies in a thread).
+   */
+  noReply?: boolean
   /**
    * Lazy preprocessing callback. When set, the runtime serializes it via a
    * lightweight promise chain (preprocessChain) to resolve prompt/images/mode
@@ -2838,6 +2846,18 @@ export class ThreadSessionRuntime {
         return
       }
 
+      // Context-only messages (noReply) should not create a new session.
+      // If there is no existing session, silently skip.
+      if (input.noReply) {
+        const existingSessionId = this.state?.sessionId || await getThreadSession(this.thread.id) || undefined
+        if (!existingSessionId) {
+          logger.log(
+            `[INGRESS] Skipping noReply message for thread ${this.threadId}: no existing session`,
+          )
+          return
+        }
+      }
+
       // Helper: stop typing and drain queued local messages on error.
       const cleanupOnError = async (errorMessage: string) => {
         this.stopTyping()
@@ -3063,6 +3083,7 @@ export class ThreadSessionRuntime {
         ...(resolvedAgent ? { agent: resolvedAgent } : {}),
         ...(modelField ? { model: modelField } : {}),
         ...variantField,
+        ...(input.noReply ? { noReply: true } : {}),
       }
       const promptResult = await getClient().session.promptAsync(request)
         .catch((e) => new OpenCodeSdkError({ operation: 'session.promptAsync', cause: e }))
@@ -3082,7 +3103,10 @@ export class ThreadSessionRuntime {
         `[INGRESS] promptAsync accepted by opencode queue sessionId=${session.id} threadId=${this.threadId}`,
       )
 
-      this.markQueueDispatchBusy(session.id)
+      // noReply messages don't trigger the agent loop, so don't mark as busy
+      if (!input.noReply) {
+        this.markQueueDispatchBusy(session.id)
+      }
     })
 
     if (skippedBySessionGuard) {
@@ -3241,8 +3265,15 @@ export class ThreadSessionRuntime {
         // Route with the resolved mode through normal paths.
         // Await the enqueue so session state (ensureSession, setThreadSession)
         // is persisted before the next message's preprocessing reads it.
-        const enqueueResult =
-          resolvedInput.mode === 'local-queue' || resolvedInput.command
+        // noReply messages always go through the opencode path so the flag
+        // reaches promptAsync; local queue doesn't support noReply.
+        const enqueueResult = resolvedInput.noReply
+          ? await this.submitViaOpencodeQueue({
+              ...resolvedInput,
+              mode: 'opencode',
+              command: undefined,
+            })
+          : (resolvedInput.mode === 'local-queue' || resolvedInput.command)
             ? await this.enqueueViaLocalQueue(resolvedInput)
             : await this.submitViaOpencodeQueue(resolvedInput)
         resolveOuter(enqueueResult)

package/src/store.ts

@@ -110,6 +110,13 @@ export type KimakiState = {
   // Read by: cli-runner.ts run() before calling backgroundUpgradeKimaki().
   autoUpgradeEnabled: boolean
 
+  // When true, all new sessions from channel messages create git worktrees.
+  // Set once at startup from --worktrees CLI flag. The per-channel toggle
+  // (getChannelWorktreesEnabled) is checked separately; this is the global override.
+  // Changes: set once at startup.
+  // Read by: discord-bot.ts message handler, commands/agent.ts quick-agent with prompt.
+  useWorktrees: boolean
+
   // Whether background sync of external OpenCode sessions is enabled.
   // When true (default), sessions started from the OpenCode CLI or TUI
   // are mirrored into Discord threads so they can be browsed, searched,
@@ -172,6 +179,7 @@ export const store = createStore<KimakiState>(() => ({
   allowedMentions: ['users'],
   allowAllUsers: false,
   permissionTimeoutMs: 10 * 60 * 1000,
+  useWorktrees: false,
   autoUpgradeEnabled: true,
   syncEnabled: true,
   discordBaseUrl: 'https://discord.com',