kimaki 0.18.0 → 0.19.0

package/dist/cli-commands/send.js

@@ -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';
@@ -271,9 +275,18 @@ cli
             if (!threadData.parent_id) {
                 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) {
-                throw new Error('Thread parent channel is not configured with a project directory');
+            // 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. ' +
+                    `${flag} requires a local project mapping. Run the bot first to sync channel data.`);
             }
             if (parsedSchedule) {
                 const payload = {
@@ -298,6 +311,7 @@ cli
                     channelId: threadData.parent_id,
                     threadId: targetThreadId,
                     sessionId: sessionId || undefined,
+                    // 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}`;
@@ -337,6 +351,8 @@ cli
                 process.stdout.write(`Session: ${existingSessionId}\n`);
             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,
@@ -352,17 +368,25 @@ cli
         }
         // Get channel info to extract directory from topic
         const channelData = (await rest.get(Routes.channel(channelId)));
+        // 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);
-        if (!channelConfig && !notifyOnly) {
-            cliLogger.log('Channel not configured');
-            throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
-        }
         const projectDirectory = channelConfig?.directory;
+        // 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. ` +
+                `${parsedSchedule ? '--send-at' : options.wait ? '--wait' : '--cwd'} requires a local project mapping. ` +
+                'Run the bot first to sync channel data.');
+        }
         // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd;
         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,
@@ -510,8 +534,8 @@ cli
             process.stdout.write(`Session: ${newSessionId}\n`);
         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/dist/cli-commands/session.js

@@ -126,6 +126,7 @@ cli
 cli
     .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
     .option('--project <path>', 'Project directory (defaults to cwd)')
+    .option('--verbose', 'Show full tool inputs and outputs instead of compact summaries')
     .action(async (sessionId, options) => {
     try {
         const projectDirectory = path.resolve(options.project || '.');
@@ -137,8 +138,9 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         // 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);
@@ -171,6 +173,7 @@ cli
             const otherMarkdown = new ShareMarkdown(otherClient());
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
+                compactTools,
             });
             if (!(otherResult instanceof Error)) {
                 process.stdout.write(otherResult);

package/dist/markdown.js

@@ -26,7 +26,7 @@ export class ShareMarkdown {
      * @returns Error or markdown string
      */
     async generate(options) {
-        const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
+        const { sessionID, includeSystemInfo, lastAssistantOnly, compactTools = true } = options;
         // Get session info
         const sessionResponse = await this.client.session.get({
             sessionID,
@@ -75,13 +75,13 @@ export class ShareMarkdown {
             lines.push('');
         }
         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('');
         }
         return lines.join('\n');
     }
-    renderMessage(message, parts) {
+    renderMessage(message, parts, opts) {
         const lines = [];
         if (message.role === 'user') {
             lines.push('### 👤 User');
@@ -128,7 +128,9 @@ export class ShareMarkdown {
                 return true;
             });
             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);
             }
             // Add completion time if available
@@ -214,6 +216,59 @@ export class ShareMarkdown {
         }
         return lines;
     }
+    /** Compact rendering: tool calls become a single line with line count instead of full output. */
+    renderPartCompact(part, message) {
+        // Non-tool parts render the same as verbose
+        if (part.type !== 'tool') {
+            return this.renderPart(part, message);
+        }
+        const lines = [];
+        if (part.state.status === 'completed') {
+            const output = 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. */
+    compactInputSummary(input) {
+        if (!input)
+            return '';
+        const entries = Object.entries(input);
+        if (entries.length === 0)
+            return '';
+        const parts = [];
+        const maxParams = 2;
+        for (let i = 0; i < Math.min(entries.length, maxParams); i++) {
+            const [key, value] = entries[i];
+            let val;
+            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(', ');
+    }
     formatDuration(ms) {
         if (ms < 1000)
             return `${ms}ms`;

package/dist/markdown.test.js

@@ -36,6 +36,18 @@ function createMatchers() {
             ],
         },
     };
+    const toolCallMatcher = {
+        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 = {
         id: 'default-reply',
         priority: 1,
@@ -49,12 +61,13 @@ function createMatchers() {
             ],
         },
     };
-    return [helloMatcher, defaultMatcher];
+    return [helloMatcher, toolCallMatcher, defaultMatcher];
 }
 let client;
 let directories;
 let testStartTime;
 let sessionID;
+let toolSessionID;
 beforeAll(async () => {
     testStartTime = Date.now();
     directories = createRunDirectories();
@@ -117,7 +130,34 @@ 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) {
         await cleanupTestSessions({
@@ -262,3 +302,34 @@ 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');
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -25,9 +25,9 @@
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.0",
-    "db": "^0.0.0",
     "opencode-cached-provider": "^0.0.1",
-    "opencode-deterministic-provider": "^0.0.1"
+    "opencode-deterministic-provider": "^0.0.1",
+    "db": "^0.0.0"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.53",

package/skills/sigillo/SKILL.md

@@ -199,6 +199,40 @@ After setup, `sigillo run` in any subdirectory uses that project + environment a
 
 Avoid `sigillo secrets download` unless a specific tool requires a file. Prefer injecting directly via `sigillo run --` so values never touch the filesystem.
 
+## Placeholder secrets (user fills in later)
+
+When the user asks to add a secret but will provide the actual value later via the dashboard, set it with an empty value:
+
+```bash
+sigillo secrets set DATABASE_URL ""
+```
+
+This creates the secret as a placeholder. The CLI shows `empty: true` when listing secrets so empty placeholders are visible. After setting the placeholder, always print the dashboard URL so the user can fill it in:
+
+```
+https://sigillo.dev/dash/projects/<PROJECT_ID>/envs/<ENV_SLUG>
+```
+
+Replace `<PROJECT_ID>` and `<ENV_SLUG>` with the actual values from the current setup. To find them:
+
+```bash
+sigillo secrets
+```
+
+The `environment_id` in the output is the env ID. The project ID is from `sigillo setup` or `sigillo projects`.
+
+To set placeholders across all environments at once:
+
+```bash
+sigillo secrets set DATABASE_URL "" -c dev -c preview -c prod
+```
+
+For secrets that need real random values immediately (auth secrets, encryption keys), generate them instead of leaving empty:
+
+```bash
+sigillo secrets set AUTH_SECRET "$(openssl rand -base64 32)" -c dev -c preview -c prod
+```
+
 ## Bootstrapping a project for a new codebase
 
 When a codebase needs Sigillo for the first time, the agent creates the org, project, and placeholder secrets. The user fills in real values later via the web UI.

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/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')
+})

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`