kimaki 0.19.0 → 0.20.0

package/skills/holocron/SKILL.md

@@ -43,6 +43,7 @@ When the user asks about a specific workflow, fetch the matching page directly:
 - **Node deploy**: https://holocron.so/docs/deploy/node.md
 - **Holocron deploy**: https://holocron.so/docs/deploy/holocron.md
 - **AI assistant docs**: https://holocron.so/docs/ai/assistant.md
+- **Bleed**: https://holocron.so/docs/customize/bleed.md
 
 ```bash
 curl -fsSL https://holocron.so/docs/quickstart.md
@@ -326,6 +327,36 @@ sidebarTitle: Auth Providers
 below the title and in search engine snippets. Write a single sentence that
 summarizes the page content. Longer descriptions get truncated with an ellipsis.
 
+## Page titles (MUST follow)
+
+Holocron renders the browser `<title>` as `{page title} — {site name}`. Two
+frontmatter fields control what appears where:
+
+- **`title`** — browser tab, Google results, OG image, page heading. Write for SEO.
+- **`sidebarTitle`** — sidebar navigation only. Write for scannability (short label).
+
+**Always set both.** `title` is the full descriptive phrase; `sidebarTitle` is
+the short sidebar label. Without `sidebarTitle`, the full title shows in the
+sidebar and often wraps or looks verbose.
+
+```mdx
+---
+title: Open-source browser automation for AI agents
+sidebarTitle: Home
+description: Automate any browser with a simple TypeScript API.
+---
+```
+
+Browser tab: `Open-source browser automation for AI agents — Playwriter`
+Sidebar: `Home`
+
+**Rules:**
+
+- **Never set `title` identical to the site name.** `Playwriter — Playwriter` is redundant.
+- **Every `title` MUST be descriptive, not a generic label.** `Introduction`, `Getting Started`, `Overview` say nothing in a browser tab. Write what the page covers.
+- **Every `title` MUST be unique across the site.**
+- **`index.mdx` MUST use `sidebarTitle: Home`** (or `Overview`) and a descriptive `title`.
+
 ## Custom entry (mounting docs inside a Spiceflow app)
 
 When the site mounts Holocron inside an existing **Spiceflow** app (the `entry`
@@ -416,6 +447,12 @@ below the main content to accommodate the aside height. Keep aside callouts
 short, and only place them in sections that have at least a few paragraphs of
 body text.
 
+## Moving or renaming a page
+
+When moving or renaming a page, **always add a redirect** from the old slug to
+the new one so existing links and bookmarks don't break. Update internal links
+in other pages and the slug in `docs.json` navigation to match.
+
 ## New pages and navigation
 
 After creating a new `.mdx` or `.md` page, add its slug to `docs.jsonc`
@@ -569,7 +606,7 @@ Use ASCII diagrams frequently in MDX pages. Always use the **`diagram`** languag
 - Never exceed 94 characters per line.
 - Prefer a **varied, organic layout**. Mix plain text labels, boxes for major components, and directional arrows.
 - All connections must use **directional arrows**. Never use plain lines without an arrowhead.
-- Verify alignment by counting characters precisely.
+- Verify alignment by running `npx -y @holocron.so/cli diagrams fix <file>` (see dedicated section below).
 
 ````mdx
 ```diagram
@@ -590,6 +627,23 @@ docs.jsonc ───►│  Vite Plugin  │──────► Build Output
 ```
 ````
 
+## Always run `diagrams fix` after editing diagrams
+
+LLMs cannot count characters reliably. Every time you create or edit a diagram in an MDX page, you **must** run the alignment fixer before committing. This is not optional.
+
+```bash
+npx -y @holocron.so/cli diagrams fix path/to/file.mdx
+```
+
+The command:
+- Fixes box alignment (padding, border widths, junctions) in-place
+- Reports how many lines were changed
+- Exits with code 1 if any lines exceed max width (94 cols by default)
+
+If the output says "No changes", the diagram was already correct. If it reports width violations, shorten the offending lines manually and re-run.
+
+**Do not skip this step.** Even if the diagram looks correct in your editor, run the command. Off-by-one padding errors are invisible to LLMs but obvious to humans in monospace fonts.
+
 ## OpenAPI summaries
 
 OpenAPI operation `summary` fields become sidebar titles. The sidebar is only
@@ -601,6 +655,15 @@ characters. Use the same concise style as page `sidebarTitle` fields.
 - Never repeat the tag/group name in the summary. If the tag is `Deploy`, the summary should not start with "Deploy".
 - If the summary reads well as a sidebar label at 230px, it is short enough.
 
+## Bleed — extending content past the prose column
+
+Always wrap **YouTube embeds, videos, and large images** in `<div className='bleed'>`
+so they extend into both page margins instead of sitting at narrow prose width.
+`<Frame>` also accepts `className='bleed'`. Containers like Callout, Card, and
+Accordion apply `no-bleed` automatically to keep descendants inside their frame.
+
+See https://holocron.so/docs/customize/bleed.md for the full reference.
+
 ## Agent rules
 
 - **Always place MDX pages inside the Holocron `pagesDir`.** Before creating or
@@ -614,5 +677,7 @@ characters. Use the same concise style as page `sidebarTitle` fields.
 - All ASCII diagrams in MDX pages must use the `diagram` language hint on the
   code fence (` ```diagram `). This renders them with proper styling on the
   website instead of plain monospace.
+- After creating or editing any diagram, run `npx -y @holocron.so/cli diagrams fix <file>`
+  to auto-fix alignment. LLMs cannot count characters reliably.
 - Never pipe curl or `--help` output through `head`, `tail`, or any truncation
   command. Always read the full output.

package/skills/zele/SKILL.md

@@ -47,3 +47,16 @@ The README and `zele --help` output are the source of truth for commands, option
    ```
 5. **Google-only features** (labels, Gmail filters, `zele cal *`, full profile) fail on IMAP accounts with a clear error. Check `zele whoami` output for account type before using them.
 6. **Headless Google login** requires a tmux wrapper because `zele login` is interactive. See the README "Remote / headless login" section for the exact pattern.
+7. **Waiting for emails** with `zele mail watch`. It polls for new emails matching a filter and exits as soon as one arrives. Use this to wait for replies, verification codes, or any expected email:
+   ```bash
+   # wait for a reply from alice (no timeout, blocks until match)
+   zele mail watch --filter "is:unread from:alice@example.com"
+
+   # wait for a verification code with a 5-minute timeout
+   zele mail watch --filter "is:unread subject:verification" --timeout 300
+
+   # send an email then wait for the reply
+   zele mail send --to bob@example.com --subject "Question" --body "Hey, can you check this?"
+   zele mail watch --filter "is:unread from:bob@example.com subject:Re:Question" --timeout 600
+   ```
+   If the matched email wasn't the expected one, call `zele mail watch` again with a more specific filter. Exit code 0 means a match was found, exit code 1 means timeout.

package/src/cli-commands/project.ts

@@ -5,7 +5,7 @@ import { note } from '@clack/prompts'
 import YAML from 'yaml'
 import * as errore from 'errore'
 import type { OpencodeClient, Event as OpenCodeEvent } from '@opencode-ai/sdk/v2'
-import { Events, ActivityType, type PresenceStatusData, type Guild, Routes } from 'discord.js'
+import { Events, ActivityType, type PresenceStatusData, type Guild, type Client, Routes } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
 import { fileURLToPath } from 'node:url'
@@ -98,74 +98,7 @@ cli
 
       cliLogger.log('Finding guild...')
 
-      // Find guild
-      let guild: Guild
-      if (options.guild) {
-        const guildId = String(options.guild)
-        const foundGuild = client.guilds.cache.get(guildId)
-        if (!foundGuild) {
-          cliLogger.log('Guild not found')
-          cliLogger.error(`Guild not found: ${guildId}`)
-          void client.destroy()
-          process.exit(EXIT_NO_RESTART)
-        }
-        guild = foundGuild
-      } else {
-        const existingChannelId = await (await getDb()).query.channel_directories.findFirst({
-          where: { channel_type: 'text' },
-          orderBy: { created_at: 'desc' },
-          columns: { channel_id: true },
-        }).then((row) => row?.channel_id)
-
-        if (existingChannelId) {
-          try {
-            const ch = await client.channels.fetch(existingChannelId)
-            if (ch && !ch.isDMBased()) {
-              guild = ch.guild
-            } else {
-              throw new Error('Channel has no guild')
-            }
-          } catch (error) {
-            cliLogger.debug(
-              'Failed to fetch existing channel while selecting guild:',
-              error instanceof Error ? error.stack : String(error),
-            )
-            let firstGuild = client.guilds.cache.first()
-            if (!firstGuild) {
-              // Cache might be empty, try fetching guilds from API
-              const fetched = await client.guilds.fetch()
-              const firstOAuth2Guild = fetched.first()
-              if (firstOAuth2Guild) {
-                firstGuild = await client.guilds.fetch(firstOAuth2Guild.id)
-              }
-            }
-            if (!firstGuild) {
-              cliLogger.log('No guild found')
-              cliLogger.error('No guild found. Add the bot to a server first.')
-              void client.destroy()
-              process.exit(EXIT_NO_RESTART)
-            }
-            guild = firstGuild
-          }
-        } else {
-          let firstGuild = client.guilds.cache.first()
-          if (!firstGuild) {
-            // Cache might be empty, try fetching guilds from API
-            const fetched = await client.guilds.fetch()
-            const firstOAuth2Guild = fetched.first()
-            if (firstOAuth2Guild) {
-              firstGuild = await client.guilds.fetch(firstOAuth2Guild.id)
-            }
-          }
-          if (!firstGuild) {
-            cliLogger.log('No guild found')
-            cliLogger.error('No guild found. Add the bot to a server first.')
-            void client.destroy()
-            process.exit(EXIT_NO_RESTART)
-          }
-          guild = firstGuild
-        }
-      }
+      const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild })
 
       // Check if channel already exists in this guild
       cliLogger.log('Checking for existing channel...')
@@ -466,24 +399,7 @@ cli
       client.login(botToken).catch(reject)
     })
 
-    let guild: Guild
-    if (options.guild) {
-      const found = client.guilds.cache.get(options.guild)
-      if (!found) {
-        cliLogger.error(`Guild not found: ${options.guild}`)
-        void client.destroy()
-        process.exit(EXIT_NO_RESTART)
-      }
-      guild = found
-    } else {
-      const first = client.guilds.cache.first()
-      if (!first) {
-        cliLogger.error('No guild found. Add the bot to a server first.')
-        void client.destroy()
-        process.exit(EXIT_NO_RESTART)
-      }
-      guild = first
-    }
+    const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild })
 
     const { textChannelId, channelName } = await createProjectChannels({
       guild,
@@ -505,4 +421,100 @@ cli
   })
 
 
+// Resolve the guild for project add/create commands. In gateway mode the
+// guild cache only contains authorized guilds, so picking from cache is safe.
+// The old approach fetched an existing channel to infer the guild, but that
+// breaks when the channel belongs to a different guild (e.g. old self-hosted
+// bot channels) and the gateway proxy rejects the REST call. This led to a
+// non-deterministic fallback that picked the wrong guild.
+async function resolveGuildForProjectCommand({ client, guildIdOverride }: { client: Client; guildIdOverride?: string }): Promise<Guild> {
+  if (guildIdOverride) {
+    const found = client.guilds.cache.get(guildIdOverride)
+    if (!found) {
+      cliLogger.error(`Guild not found: ${guildIdOverride}`)
+      void client.destroy()
+      process.exit(EXIT_NO_RESTART)
+    }
+    return found
+  }
+
+  // Try existing channel lookup to find the guild the user already has channels in.
+  // This handles multi-guild setups where we want to add to the same guild.
+  const db = await getDb()
+  const existingChannels = await db.query.channel_directories.findMany({
+    where: { channel_type: 'text' },
+    orderBy: { created_at: 'desc' },
+    columns: { channel_id: true },
+    limit: 20,
+  })
+
+  // Log available guilds for debugging guild selection issues
+  const cachedGuilds = Array.from(client.guilds.cache.values())
+  cliLogger.debug(`Guilds in cache (${cachedGuilds.length}): ${cachedGuilds.map((g) => `${g.name} (${g.id})`).join(', ')}`)
+
+  // When multiple guilds are available, find which guild has the most
+  // existing channels. The user's main guild will have far more channels
+  // than a test/demo guild.
+  const guildHits = new Map<string, { guild: Guild; count: number }>()
+  for (const row of existingChannels) {
+    try {
+      const ch = await client.channels.fetch(row.channel_id)
+      if (ch && !ch.isDMBased()) {
+        const entry = guildHits.get(ch.guild.id)
+        if (entry) {
+          entry.count++
+        } else {
+          guildHits.set(ch.guild.id, { guild: ch.guild, count: 1 })
+        }
+      }
+    } catch {
+      // Channel might be in a different guild (gateway proxy rejects) or deleted, skip
+    }
+  }
+
+  if (guildHits.size > 0) {
+    // Pick the guild with the most channels
+    const best = Array.from(guildHits.values()).sort((a, b) => b.count - a.count)[0]!
+    cliLogger.debug(
+      `Guild channel counts: ${Array.from(guildHits.values()).map((e) => `${e.guild.name} (${e.guild.id}): ${e.count}`).join(', ')}`,
+    )
+    cliLogger.debug(`Selected guild: ${best.guild.name} (${best.guild.id}) with ${best.count} channels`)
+    return best.guild
+  }
+
+  cliLogger.debug('Could not resolve guild from existing channels, falling back to cache')
+
+  // If only one guild in cache, use it directly (common case).
+  // If multiple guilds, error out and ask the user to specify --guild
+  // since we can't determine which one to use.
+  if (cachedGuilds.length === 1) {
+    return cachedGuilds[0]!
+  }
+  if (cachedGuilds.length > 1) {
+    cliLogger.error(
+      `Multiple guilds found. Use --guild to specify which one:\n${cachedGuilds.map((g) => `  ${g.id}  ${g.name}`).join('\n')}`,
+    )
+    void client.destroy()
+    process.exit(EXIT_NO_RESTART)
+  }
+
+  // Cache empty, try fetching
+  const fetched = await client.guilds.fetch()
+  if (fetched.size === 1) {
+    const firstOAuth2Guild = fetched.first()!
+    return await client.guilds.fetch(firstOAuth2Guild.id)
+  }
+  if (fetched.size > 1) {
+    cliLogger.error(
+      `Multiple guilds found. Use --guild to specify which one:\n${Array.from(fetched.values()).map((g) => `  ${g.id}  ${g.name}`).join('\n')}`,
+    )
+    void client.destroy()
+    process.exit(EXIT_NO_RESTART)
+  }
+
+  cliLogger.error('No guild found. Add the bot to a server first.')
+  void client.destroy()
+  process.exit(EXIT_NO_RESTART)
+}
+
 export default cli

package/src/commands/agent.ts

@@ -21,6 +21,7 @@ import {
   getThreadSession,
   getSessionAgent,
   getChannelAgent,
+  getChannelWorktreesEnabled,
 } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import {
@@ -32,6 +33,14 @@ import {
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import { getCurrentModelInfo } from './model.js'
+import { isGitRepositoryRoot } from '../worktrees.js'
+import {
+  formatAutoWorktreeName,
+  createWorktreeInBackground,
+  worktreeCreatingMessage,
+} from './new-worktree.js'
+import { WORKTREE_PREFIX } from './merge-worktree.js'
+import { store } from '../store.js'
 
 const agentLogger = createLogger(LogPrefix.AGENT)
 
@@ -597,26 +606,78 @@ async function handleQuickAgentWithPrompt({
 
     await command.deferReply()
 
+    // Check if worktrees should be enabled (CLI flag OR channel setting),
+    // mirroring the logic in discord-bot.ts message handler.
+    const wantsWorktrees =
+      store.getState().useWorktrees ||
+      (await getChannelWorktreesEnabled(channel.id))
+    const shouldUseWorktrees =
+      wantsWorktrees && (await isGitRepositoryRoot(projectDirectory))
+
+    if (wantsWorktrees && !shouldUseWorktrees) {
+      agentLogger.warn(
+        `[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`,
+      )
+    }
+
+    const baseThreadName = prompt.slice(0, 80)
+    const threadName = shouldUseWorktrees
+      ? `${WORKTREE_PREFIX}${baseThreadName}`
+      : baseThreadName
+
     const starterMessage = await channel.send({
       content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
       flags: SILENT_MESSAGE_FLAGS,
     })
 
     const thread = await starterMessage.startThread({
-      name: prompt.slice(0, 80),
+      name: threadName.slice(0, 80),
       autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
       reason: `${resolvedAgentName} agent prompt`,
     })
 
     await thread.members.add(command.user.id)
 
-    await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
+    // Create worktree in background if enabled, same as discord-bot.ts
+    let worktreePromise: Promise<string | Error> | undefined
+    if (shouldUseWorktrees) {
+      const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50))
+      agentLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`)
+
+      const worktreeStatusMessage = await thread
+        .send({
+          content: worktreeCreatingMessage(worktreeName),
+          flags: SILENT_MESSAGE_FLAGS,
+        })
+        .catch(() => undefined)
+
+      worktreePromise = createWorktreeInBackground({
+        thread,
+        starterMessage: worktreeStatusMessage,
+        worktreeName,
+        projectDirectory,
+        rest: command.client.rest,
+      })
+    }
+
+    const sessionDirectory = await (async () => {
+      if (!worktreePromise) return projectDirectory
+      const result = await worktreePromise
+      if (result instanceof Error) return projectDirectory
+      return result
+    })()
+
+    await command
+      .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
+      .catch(() => {
+        agentLogger.warn('[AGENT] Failed to edit quick-agent reply, continuing session')
+      })
 
     const runtime = getOrCreateRuntime({
       threadId: thread.id,
       thread,
       projectDirectory,
-      sdkDirectory: projectDirectory,
+      sdkDirectory: sessionDirectory,
       channelId: channel.id,
       appId,
     })

package/src/discord-bot.ts

@@ -297,6 +297,8 @@ export async function startDiscordBot({
     discordClient = await createDiscordClient()
   }
 
+  store.setState({ useWorktrees: Boolean(useWorktrees) })
+
   let currentAppId: string | undefined = appId
 
   const setupHandlers = async (c: Client<true>) => {
@@ -503,15 +505,14 @@ export async function startDiscordBot({
         }
       }
 
-      // Ignore messages that start with a mention of another user (not the bot).
-      // These are likely users talking to each other, not the bot.
+      // Detect messages that start with a mention of another user (not the bot).
+      // In channels these are fully ignored. In threads they are added to the
+      // session context without triggering the AI (noReply), so the agent sees
+      // user-to-user conversation on the next real turn.
       const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/)
-      if (leadingMentionMatch) {
-        const mentionedUserId = leadingMentionMatch[1]
-        if (mentionedUserId !== discordClient.user?.id) {
-          return
-        }
-      }
+      const isLeadingMentionToOtherUser =
+        leadingMentionMatch &&
+        leadingMentionMatch[1] !== discordClient.user?.id
 
       if (message.partial) {
         discordLogger.log(`Fetching partial message ${message.id}`)
@@ -530,6 +531,14 @@ export async function startDiscordBot({
       // When mention mode is enabled, users without Kimaki role can message
       // without getting a permission error - we just silently ignore.
       const channel = message.channel
+
+      // In text channels, messages starting with a mention to another user
+      // are fully ignored before any permission or mention-mode checks.
+      // This prevents permission-error replies for user-to-user conversation.
+      if (channel.type === ChannelType.GuildText && isLeadingMentionToOtherUser) {
+        return
+      }
+
       if (channel.type === ChannelType.GuildText && !isCliInjectedPrompt) {
         const mentionModeEnabled = await getChannelMentionMode(channel.id)
         if (mentionModeEnabled) {
@@ -629,6 +638,13 @@ export async function startDiscordBot({
           return
         }
 
+        // Context-only messages (user-to-user replies) can't be stored without
+        // an existing session. Skip early to avoid creating a runtime or running
+        // preprocessing for nothing.
+        if (isLeadingMentionToOtherUser && !hasExistingSession) {
+          return
+        }
+
         const parent = thread.parent as TextChannel | null
         let projectDirectory: string | undefined
         if (parent) {
@@ -713,7 +729,7 @@ export async function startDiscordBot({
           projectDirectory && worktreeInfo?.status !== 'pending'
             ? extractBtwSuffix(message.content || '')
             : null
-        if (btwResult?.forceBtw && projectDirectory) {
+        if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
           const result = await forkSessionToBtwThread({
             sourceThread: thread,
             projectDirectory,
@@ -775,7 +791,9 @@ export async function startDiscordBot({
         })
 
         // Cancel interactive UI when a real user sends a message.
-        if (!message.author.bot && !isCliInjectedPrompt) {
+        // Context-only messages (user-to-user replies) should not interrupt
+        // the active run or dismiss pending UI.
+        if (!message.author.bot && !isCliInjectedPrompt && !isLeadingMentionToOtherUser) {
           cancelPendingActionButtons(thread.id)
           cancelHtmlActionsForThread(thread.id)
           const dismissedPermission = await cancelPendingPermission(thread.id)
@@ -812,6 +830,7 @@ export async function startDiscordBot({
           model: cliInjectedModel,
           permissions: cliInjectedPermissions,
           injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+          noReply: isLeadingMentionToOtherUser || undefined,
           sessionStartSource: sessionStartSource
             ? {
                 scheduleKind: sessionStartSource.scheduleKind,

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 = {