kimaki 0.18.0 → 0.20.0

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/cli-commands/send.ts

@@ -1,4 +1,8 @@
 // Terminal send command for creating Discord threads and scheduling prompts.
+// Designed to work in CI/headless environments with just KIMAKI_BOT_TOKEN.
+// The local SQLite database (channel_directories) is NOT required for the basic
+// flow: post message → create thread → remote bot picks it up. The local project
+// directory mapping is only needed for --send-at, --wait, and --cwd.
 import { goke } from 'goke'
 import { z } from 'zod'
 import { note } from '@clack/prompts'
@@ -395,10 +399,20 @@ cli
             throw new Error(`Thread has no parent channel: ${targetThreadId}`)
           }
 
+          // channelConfig is optional: in CI/headless environments the local DB
+          // has no channel_directories rows because the bot hasn't synced yet.
+          // The running bot on the other end resolves the directory from its own DB.
+          // We only require it for features that genuinely need a local directory
+          // (scheduled tasks and --wait).
           const channelConfig = await getChannelDirectory(threadData.parent_id)
-          if (!channelConfig) {
+
+          // Guard early: fail before sending the message if a feature that
+          // needs local project directory mapping is requested.
+          if (!channelConfig && (parsedSchedule || options.wait)) {
+            const flag = parsedSchedule ? '--send-at' : '--wait'
             throw new Error(
-              'Thread parent channel is not configured with a project directory',
+              'Thread parent channel is not configured with a project directory. ' +
+              `${flag} requires a local project mapping. Run the bot first to sync channel data.`,
             )
           }
 
@@ -425,7 +439,8 @@ cli
               channelId: threadData.parent_id,
               threadId: targetThreadId,
               sessionId: sessionId || undefined,
-              projectDirectory: channelConfig.directory,
+              // channelConfig is guaranteed: early guard threw if missing with --send-at
+              projectDirectory: channelConfig!.directory,
             })
 
             const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`
@@ -475,10 +490,12 @@ cli
           process.stdout.write(`${threadUrl}\n`)
 
           if (options.wait) {
+            // channelConfig is guaranteed here: early guard above already
+            // threw if channelConfig is missing when --wait is used.
             const { waitAndOutputSession } = await import('../wait-session.js')
             await waitAndOutputSession({
               threadId: targetThreadId,
-              projectDirectory: channelConfig.directory,
+              projectDirectory: channelConfig!.directory,
               waitStartedAtMs,
             })
           }
@@ -500,22 +517,29 @@ cli
           guild_id: string
         }
 
+        // channelConfig is optional: in CI/headless environments the local DB
+        // has no channel_directories rows because the bot hasn't synced yet.
+        // The running bot on the other end resolves the directory from its own DB.
+        // We only require it for features that genuinely need a local directory
+        // (--send-at, --wait, --cwd).
         const channelConfig = await getChannelDirectory(channelData.id)
+        const projectDirectory = channelConfig?.directory
 
-        if (!channelConfig && !notifyOnly) {
-          cliLogger.log('Channel not configured')
+        // Features that require a local project directory mapping
+        const needsProjectDirectory = Boolean(parsedSchedule || options.wait || options.cwd)
+        if (!channelConfig && needsProjectDirectory) {
           throw new Error(
-            `Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`,
+            `Channel #${channelData.name} is not configured with a project directory. ` +
+            `${parsedSchedule ? '--send-at' : options.wait ? '--wait' : '--cwd'} requires a local project mapping. ` +
+            'Run the bot first to sync channel data.',
           )
         }
 
-        const projectDirectory = channelConfig?.directory
-
         // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd: string | undefined
         if (options.cwd) {
-          // projectDirectory is guaranteed here: --cwd is incompatible with --notify-only,
-          // and non-notify sends already require channelConfig above.
+          // projectDirectory is guaranteed here: needsProjectDirectory check above
+          // already threw if channelConfig is missing when --cwd is used.
           const cwdResult = await resolveSessionWorkingDirectory({
             projectDirectory: projectDirectory!,
             candidatePath: options.cwd,
@@ -690,8 +714,8 @@ cli
         process.stdout.write(`${threadUrl}\n`)
 
         if (options.wait) {
-          // projectDirectory is guaranteed here: --wait is incompatible with --notify-only,
-          // and non-notify sends already require channelConfig above.
+          // projectDirectory is guaranteed here: needsProjectDirectory check above
+          // already threw if channelConfig is missing when --wait is used.
           const { waitAndOutputSession } = await import('../wait-session.js')
           await waitAndOutputSession({
             threadId: threadData.id,

package/src/cli-commands/session.ts

@@ -188,7 +188,8 @@ cli
     'Read a session conversation as markdown (pipe to file to grep)',
   )
   .option('--project <path>', 'Project directory (defaults to cwd)')
-  .action(async (sessionId: string, options: { project?: string }) => {
+  .option('--verbose', 'Show full tool inputs and outputs instead of compact summaries')
+  .action(async (sessionId: string, options: { project?: string; verbose?: boolean }) => {
     try {
       const projectDirectory = path.resolve(options.project || '.')
 
@@ -202,8 +203,9 @@ cli
       }
 
       // Try current project first (fast path)
+      const compactTools = !options.verbose
       const markdown = new ShareMarkdown(getClient())
-      const result = await markdown.generate({ sessionID: sessionId })
+      const result = await markdown.generate({ sessionID: sessionId, compactTools })
       if (!(result instanceof Error)) {
         process.stdout.write(result)
         process.exit(0)
@@ -236,6 +238,7 @@ cli
         const otherMarkdown = new ShareMarkdown(otherClient())
         const otherResult = await otherMarkdown.generate({
           sessionID: sessionId,
+          compactTools,
         })
         if (!(otherResult instanceof Error)) {
           process.stdout.write(otherResult)

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/markdown.test.ts

@@ -45,6 +45,19 @@ function createMatchers(): DeterministicMatcher[] {
     },
   }
 
+  const toolCallMatcher: DeterministicMatcher = {
+    id: 'tool-call-reply',
+    priority: 90,
+    when: { latestUserTextIncludes: 'use a tool please' },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'tool-call', toolCallId: 'tc1', toolName: 'bash', input: JSON.stringify({ command: 'echo hello world', description: 'Print greeting' }) },
+        { type: 'finish', finishReason: 'tool-calls', usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } },
+      ],
+    },
+  }
+
   const defaultMatcher: DeterministicMatcher = {
     id: 'default-reply',
     priority: 1,
@@ -59,13 +72,14 @@ function createMatchers(): DeterministicMatcher[] {
     },
   }
 
-  return [helloMatcher, defaultMatcher]
+  return [helloMatcher, toolCallMatcher, defaultMatcher]
 }
 
 let client: OpencodeClient
 let directories: ReturnType<typeof createRunDirectories>
 let testStartTime: number
 let sessionID: string
+let toolSessionID: string
 
 beforeAll(async () => {
   testStartTime = Date.now()
@@ -148,7 +162,39 @@ beforeAll(async () => {
       setTimeout(resolve, 200)
     })
   }
-}, 20_000)
+
+  // Create a second session that triggers a tool call (bash echo)
+  const toolCreateResult = await client.session.create({
+    directory: directories.projectDirectory,
+    title: 'Tool Call Session',
+  })
+  toolSessionID = toolCreateResult.data!.id
+
+  await client.session.promptAsync({
+    sessionID: toolSessionID,
+    directory: directories.projectDirectory,
+    parts: [{ type: 'text', text: 'use a tool please' }],
+  })
+
+  // Wait for tool execution to complete
+  const toolMaxWait = 15_000
+  const toolPollStart = Date.now()
+  while (Date.now() - toolPollStart < toolMaxWait) {
+    const msgs = await client.session.messages({
+      sessionID: toolSessionID,
+      directory: directories.projectDirectory,
+    })
+    const messages = msgs.data || []
+    const hasToolPart = messages.some((m) =>
+      m.parts.some((p) => p.type === 'tool' && p.state?.status === 'completed'),
+    )
+    if (hasToolPart) {
+      await new Promise((resolve) => { setTimeout(resolve, 500) })
+      break
+    }
+    await new Promise((resolve) => { setTimeout(resolve, 200) })
+  }
+}, 30_000)
 
 afterAll(async () => {
   if (directories) {
@@ -313,3 +359,44 @@ test('generate markdown with lastAssistantOnly', async () => {
   // Should contain the assistant response
   expect(markdown).toContain('Hello! This is a deterministic markdown test response.')
 })
+
+test('compact tools: tool calls show one-liner with line count', async () => {
+  const exporter = new ShareMarkdown(client)
+
+  const result = await exporter.generate({
+    sessionID: toolSessionID,
+    compactTools: true,
+  })
+
+  expect(errore.isOk(result)).toBe(true)
+  const md = errore.unwrap(result)
+
+  // Compact mode: exact one-liner format with params and line count
+  expect(md).toContain(
+    '> 🛠️ **bash** command=echo hello world, description=Print greeting',
+  )
+  expect(md).toMatch(/\(\d+ lines?\)/)
+  // Should NOT contain full output code blocks or input YAML
+  expect(md).not.toContain('**Output:**')
+  expect(md).not.toContain('**Input:**')
+  expect(md).not.toContain('```yaml')
+})
+
+test('verbose tools: tool calls show full input and output', async () => {
+  const exporter = new ShareMarkdown(client)
+
+  const result = await exporter.generate({
+    sessionID: toolSessionID,
+    compactTools: false,
+  })
+
+  expect(errore.isOk(result)).toBe(true)
+  const md = errore.unwrap(result)
+
+  // Verbose mode: full tool rendering with input YAML and output code block
+  expect(md).toContain('#### 🛠️ Tool: bash')
+  expect(md).toContain('**Input:**')
+  expect(md).toContain('```yaml')
+  expect(md).toContain('**Output:**')
+  expect(md).toContain('hello world')
+})