kimaki 0.4.25 → 0.4.27

package/dist/discord-utils.js

@@ -56,29 +56,86 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
     const chunks = [];
     let currentChunk = '';
     let currentLang = null;
+    // helper to split a long line into smaller pieces at word boundaries or hard breaks
+    const splitLongLine = (text, available, inCode) => {
+        const pieces = [];
+        let remaining = text;
+        while (remaining.length > available) {
+            let splitAt = available;
+            // for non-code, try to split at word boundary
+            if (!inCode) {
+                const lastSpace = remaining.lastIndexOf(' ', available);
+                if (lastSpace > available * 0.5) {
+                    splitAt = lastSpace + 1;
+                }
+            }
+            pieces.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt);
+        }
+        if (remaining) {
+            pieces.push(remaining);
+        }
+        return pieces;
+    };
     for (const line of lines) {
         const wouldExceed = currentChunk.length + line.text.length > maxLength;
-        if (wouldExceed && currentChunk) {
-            if (currentLang !== null) {
-                currentChunk += '```\n';
-            }
-            chunks.push(currentChunk);
-            if (line.isClosingFence && currentLang !== null) {
-                currentChunk = '';
+        if (wouldExceed) {
+            // handle case where single line is longer than maxLength
+            if (line.text.length > maxLength) {
+                // first, flush current chunk if any
+                if (currentChunk) {
+                    if (currentLang !== null) {
+                        currentChunk += '```\n';
+                    }
+                    chunks.push(currentChunk);
+                    currentChunk = '';
+                }
+                // calculate overhead for code block markers
+                const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0;
+                const availablePerChunk = maxLength - codeBlockOverhead - 50; // safety margin
+                const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
+                for (let i = 0; i < pieces.length; i++) {
+                    const piece = pieces[i];
+                    if (line.inCodeBlock) {
+                        chunks.push('```' + line.lang + '\n' + piece + '```\n');
+                    }
+                    else {
+                        chunks.push(piece);
+                    }
+                }
                 currentLang = null;
                 continue;
             }
-            if (line.inCodeBlock || line.isOpeningFence) {
-                const lang = line.lang;
-                currentChunk = '```' + lang + '\n';
-                if (!line.isOpeningFence) {
-                    currentChunk += line.text;
+            // normal case: line fits in a chunk but current chunk would overflow
+            if (currentChunk) {
+                if (currentLang !== null) {
+                    currentChunk += '```\n';
+                }
+                chunks.push(currentChunk);
+                if (line.isClosingFence && currentLang !== null) {
+                    currentChunk = '';
+                    currentLang = null;
+                    continue;
+                }
+                if (line.inCodeBlock || line.isOpeningFence) {
+                    const lang = line.lang;
+                    currentChunk = '```' + lang + '\n';
+                    if (!line.isOpeningFence) {
+                        currentChunk += line.text;
+                    }
+                    currentLang = lang;
+                }
+                else {
+                    currentChunk = line.text;
+                    currentLang = null;
                 }
-                currentLang = lang;
             }
             else {
+                // currentChunk is empty but line still exceeds - shouldn't happen after above check
                 currentChunk = line.text;
-                currentLang = null;
+                if (line.inCodeBlock || line.isOpeningFence) {
+                    currentLang = line.lang;
+                }
             }
         }
         else {

package/dist/interaction-handler.js

@@ -6,13 +6,16 @@ import { handleSessionCommand, handleSessionAutocomplete } from './commands/sess
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js';
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
-import { handleAcceptCommand, handleRejectCommand } from './commands/permissions.js';
+import { handlePermissionSelectMenu } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu } from './commands/model.js';
+import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js';
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
+import { handleUserCommand } from './commands/user-command.js';
 import { createLogger } from './logger.js';
 const interactionLogger = createLogger('INTERACTION');
 export function registerInteractionHandler({ discordClient, appId, }) {
@@ -55,14 +58,8 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'create-new-project':
                         await handleCreateNewProjectCommand({ command: interaction, appId });
                         return;
-                    case 'accept':
-                    case 'accept-always':
-                        await handleAcceptCommand({ command: interaction, appId });
-                        return;
-                    case 'reject':
-                        await handleRejectCommand({ command: interaction, appId });
-                        return;
                     case 'abort':
+                    case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
                     case 'share':
@@ -74,6 +71,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'model':
                         await handleModelCommand({ interaction, appId });
                         return;
+                    case 'agent':
+                        await handleAgentCommand({ interaction, appId });
+                        return;
                     case 'queue':
                         await handleQueueCommand({ command: interaction, appId });
                         return;
@@ -87,6 +87,11 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleRedoCommand({ command: interaction, appId });
                         return;
                 }
+                // Handle user-defined commands (ending with -cmd suffix)
+                if (interaction.commandName.endsWith('-cmd')) {
+                    await handleUserCommand({ command: interaction, appId });
+                    return;
+                }
                 return;
             }
             if (interaction.isStringSelectMenu()) {
@@ -103,6 +108,18 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     await handleModelSelectMenu(interaction);
                     return;
                 }
+                if (customId.startsWith('agent_select:')) {
+                    await handleAgentSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('ask_question:')) {
+                    await handleAskQuestionSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('permission:')) {
+                    await handlePermissionSelectMenu(interaction);
+                    return;
+                }
                 return;
             }
         }

package/dist/logger.js

@@ -2,12 +2,50 @@
 // Creates loggers with consistent prefixes for different subsystems
 // (DISCORD, VOICE, SESSION, etc.) for easier debugging.
 import { log } from '@clack/prompts';
+import fs from 'node:fs';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isDev = !__dirname.includes('node_modules');
+const logFilePath = path.join(__dirname, '..', 'tmp', 'kimaki.log');
+// reset log file on startup in dev mode
+if (isDev) {
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`);
+}
+function writeToFile(level, prefix, args) {
+    if (!isDev) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`;
+    fs.appendFileSync(logFilePath, message);
+}
 export function createLogger(prefix) {
     return {
-        log: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        error: (...args) => log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        warn: (...args) => log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        info: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        debug: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
+        log: (...args) => {
+            writeToFile('INFO', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+            log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+            log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        debug: (...args) => {
+            writeToFile('DEBUG', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
     };
 }

package/dist/markdown.js

@@ -4,6 +4,8 @@
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
+import { createLogger } from './logger.js';
+const markdownLogger = createLogger('MARKDOWN');
 export class ShareMarkdown {
     client;
     constructor(client) {
@@ -204,3 +206,105 @@ export class ShareMarkdown {
         return `${minutes}m ${seconds}s`;
     }
 }
+/**
+ * Generate compact session context for voice transcription.
+ * Includes system prompt (optional), user messages, assistant text,
+ * and tool calls in compact form (name + params only, no output).
+ */
+export async function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
+    try {
+        const messagesResponse = await client.session.messages({
+            path: { id: sessionId },
+        });
+        const messages = messagesResponse.data || [];
+        const lines = [];
+        // Get system prompt if requested
+        // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
+        // 1. session.system field (if available in future SDK versions)
+        // 2. synthetic text part in first assistant message (current approach)
+        if (includeSystemPrompt && messages.length > 0) {
+            const firstAssistant = messages.find((m) => m.info.role === 'assistant');
+            if (firstAssistant) {
+                // look for text part marked as synthetic (system prompt)
+                const systemPart = (firstAssistant.parts || []).find((p) => p.type === 'text' && p.synthetic === true);
+                if (systemPart && 'text' in systemPart && systemPart.text) {
+                    lines.push('[System Prompt]');
+                    const truncated = systemPart.text.slice(0, 3000);
+                    lines.push(truncated);
+                    if (systemPart.text.length > 3000) {
+                        lines.push('...(truncated)');
+                    }
+                    lines.push('');
+                }
+            }
+        }
+        // Process recent messages
+        const recentMessages = messages.slice(-maxMessages);
+        for (const msg of recentMessages) {
+            if (msg.info.role === 'user') {
+                const textParts = (msg.parts || [])
+                    .filter((p) => p.type === 'text' && 'text' in p)
+                    .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+                    .filter(Boolean);
+                if (textParts.length > 0) {
+                    lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`);
+                    lines.push('');
+                }
+            }
+            else if (msg.info.role === 'assistant') {
+                // Get assistant text parts (non-synthetic, non-empty)
+                const textParts = (msg.parts || [])
+                    .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
+                    .map((p) => ('text' in p ? p.text : ''))
+                    .filter(Boolean);
+                if (textParts.length > 0) {
+                    lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`);
+                    lines.push('');
+                }
+                // Get tool calls in compact form (name + params only)
+                const toolParts = (msg.parts || []).filter((p) => p.type === 'tool' &&
+                    'state' in p &&
+                    p.state?.status === 'completed');
+                for (const part of toolParts) {
+                    if (part.type === 'tool' && 'tool' in part && 'state' in part) {
+                        const toolName = part.tool;
+                        // skip noisy tools
+                        if (toolName === 'todoread' || toolName === 'todowrite') {
+                            continue;
+                        }
+                        const input = part.state?.input || {};
+                        // compact params: just key=value on one line
+                        const params = Object.entries(input)
+                            .map(([k, v]) => {
+                            const val = typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100);
+                            return `${k}=${val}`;
+                        })
+                            .join(', ');
+                        lines.push(`[Tool ${toolName}]: ${params}`);
+                    }
+                }
+            }
+        }
+        return lines.join('\n').slice(0, 8000);
+    }
+    catch (e) {
+        markdownLogger.error('Failed to get compact session context:', e);
+        return '';
+    }
+}
+/**
+ * Get the last session for a directory (excluding the current one).
+ */
+export async function getLastSessionId({ client, excludeSessionId, }) {
+    try {
+        const sessionsResponse = await client.session.list();
+        const sessions = sessionsResponse.data || [];
+        // Sessions are sorted by time, get the most recent one that isn't the current
+        const lastSession = sessions.find((s) => s.id !== excludeSessionId);
+        return lastSession?.id || null;
+    }
+    catch (e) {
+        markdownLogger.error('Failed to get last session:', e);
+        return null;
+    }
+}

package/dist/markdown.test.js

@@ -1,7 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
 import { OpencodeClient } from '@opencode-ai/sdk';
-import { ShareMarkdown } from './markdown.js';
+import { ShareMarkdown, getCompactSessionContext } from './markdown.js';
 let serverProcess;
 let client;
 let port;
@@ -230,3 +230,33 @@ test('generate markdown from multiple sessions', async () => {
         }
     }
 });
+// test for getCompactSessionContext - disabled in CI since it requires a specific session
+test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
+    const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
+    const context = await getCompactSessionContext({
+        client,
+        sessionId,
+        includeSystemPrompt: true,
+        maxMessages: 15,
+    });
+    console.log(`Generated compact context length: ${context.length} characters`);
+    expect(context).toBeTruthy();
+    expect(context.length).toBeGreaterThan(0);
+    // should have tool calls or messages
+    expect(context).toMatch(/\[Tool \w+\]:|\[User\]:|\[Assistant\]:/);
+    await expect(context).toMatchFileSnapshot('./__snapshots__/compact-session-context.md');
+});
+test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
+    const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
+    const context = await getCompactSessionContext({
+        client,
+        sessionId,
+        includeSystemPrompt: false,
+        maxMessages: 10,
+    });
+    console.log(`Generated compact context (no system) length: ${context.length} characters`);
+    expect(context).toBeTruthy();
+    // should NOT have system prompt
+    expect(context).not.toContain('[System Prompt]');
+    await expect(context).toMatchFileSnapshot('./__snapshots__/compact-session-context-no-system.md');
+});

package/dist/message-formatting.js

@@ -1,8 +1,18 @@
 // OpenCode message part formatting for Discord.
 // Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
 // handles file attachments, and provides tool summary generation.
+import fs from 'node:fs';
+import path from 'node:path';
 import { createLogger } from './logger.js';
+const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
 const logger = createLogger('FORMATTING');
+/**
+ * Escapes Discord inline markdown characters so dynamic content
+ * doesn't break formatting when wrapped in *, _, **, etc.
+ */
+function escapeInlineMarkdown(text) {
+    return text.replace(/([*_~|`\\])/g, '\\$1');
+}
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -61,17 +71,42 @@ export async function getTextAttachments(message) {
     }));
     return textContents.join('\n\n');
 }
-export function getFileAttachments(message) {
+export async function getFileAttachments(message) {
     const fileAttachments = Array.from(message.attachments.values()).filter((attachment) => {
         const contentType = attachment.contentType || '';
         return (contentType.startsWith('image/') || contentType === 'application/pdf');
     });
-    return fileAttachments.map((attachment) => ({
-        type: 'file',
-        mime: attachment.contentType || 'application/octet-stream',
-        filename: attachment.name,
-        url: attachment.url,
+    if (fileAttachments.length === 0) {
+        return [];
+    }
+    // ensure tmp directory exists
+    if (!fs.existsSync(ATTACHMENTS_DIR)) {
+        fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+    }
+    const results = await Promise.all(fileAttachments.map(async (attachment) => {
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
+                return null;
+            }
+            const buffer = Buffer.from(await response.arrayBuffer());
+            const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
+            fs.writeFileSync(localPath, buffer);
+            logger.log(`Downloaded attachment to ${localPath}`);
+            return {
+                type: 'file',
+                mime: attachment.contentType || 'application/octet-stream',
+                filename: attachment.name,
+                url: localPath,
+            };
+        }
+        catch (error) {
+            logger.error(`Error downloading attachment ${attachment.name}:`, error);
+            return null;
+        }
     }));
+    return results.filter((r) => r !== null);
 }
 export function getToolSummaryText(part) {
     if (part.type !== 'tool')
@@ -83,48 +118,48 @@ export function getToolSummaryText(part) {
         const added = newString.split('\n').length;
         const removed = oldString.split('\n').length;
         const fileName = filePath.split('/').pop() || '';
-        return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`;
+        return fileName ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})` : `(+${added}-${removed})`;
     }
     if (part.tool === 'write') {
         const filePath = part.state.input?.filePath || '';
         const content = part.state.input?.content || '';
         const lines = content.split('\n').length;
         const fileName = filePath.split('/').pop() || '';
-        return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`;
+        return fileName ? `*${escapeInlineMarkdown(fileName)}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`;
     }
     if (part.tool === 'webfetch') {
         const url = part.state.input?.url || '';
         const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
-        return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : '';
+        return urlWithoutProtocol ? `*${escapeInlineMarkdown(urlWithoutProtocol)}*` : '';
     }
     if (part.tool === 'read') {
         const filePath = part.state.input?.filePath || '';
         const fileName = filePath.split('/').pop() || '';
-        return fileName ? `*${fileName}*` : '';
+        return fileName ? `*${escapeInlineMarkdown(fileName)}*` : '';
     }
     if (part.tool === 'list') {
         const path = part.state.input?.path || '';
         const dirName = path.split('/').pop() || path;
-        return dirName ? `*${dirName}*` : '';
+        return dirName ? `*${escapeInlineMarkdown(dirName)}*` : '';
     }
     if (part.tool === 'glob') {
         const pattern = part.state.input?.pattern || '';
-        return pattern ? `*${pattern}*` : '';
+        return pattern ? `*${escapeInlineMarkdown(pattern)}*` : '';
     }
     if (part.tool === 'grep') {
         const pattern = part.state.input?.pattern || '';
-        return pattern ? `*${pattern}*` : '';
+        return pattern ? `*${escapeInlineMarkdown(pattern)}*` : '';
     }
     if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
         return '';
     }
     if (part.tool === 'task') {
         const description = part.state.input?.description || '';
-        return description ? `_${description}_` : '';
+        return description ? `_${escapeInlineMarkdown(description)}_` : '';
     }
     if (part.tool === 'skill') {
         const name = part.state.input?.name || '';
-        return name ? `_${name}_` : '';
+        return name ? `_${escapeInlineMarkdown(name)}_` : '';
     }
     if (!part.state.input)
         return '';
@@ -151,12 +186,24 @@ export function formatTodoList(part) {
     const activeTodo = todos[activeIndex];
     if (activeIndex === -1 || !activeTodo)
         return '';
-    return `${activeIndex + 1}. **${activeTodo.content}**`;
+    // parenthesized digits ⑴-⒇ for 1-20, fallback to regular number for 21+
+    const parenthesizedDigits = '⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇';
+    const todoNumber = activeIndex + 1;
+    const num = todoNumber <= 20 ? parenthesizedDigits[todoNumber - 1] : `(${todoNumber})`;
+    const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1);
+    return `${num} **${escapeInlineMarkdown(content)}**`;
 }
 export function formatPart(part) {
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
+        const trimmed = part.text.trimStart();
+        const firstChar = trimmed[0] || '';
+        const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|'];
+        const startsWithMarkdown = markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed);
+        if (startsWithMarkdown) {
+            return `\n${part.text}`;
+        }
         return `⬥ ${part.text}`;
     }
     if (part.type === 'reasoning') {
@@ -180,6 +227,10 @@ export function formatPart(part) {
         if (part.tool === 'todowrite') {
             return formatTodoList(part);
         }
+        // Question tool is handled via Discord dropdowns, not text
+        if (part.tool === 'question') {
+            return '';
+        }
         if (part.state.status === 'pending') {
             return '';
         }
@@ -193,19 +244,18 @@ export function formatPart(part) {
             const command = part.state.input?.command || '';
             const description = part.state.input?.description || '';
             const isSingleLine = !command.includes('\n');
-            const hasUnderscores = command.includes('_');
-            if (isSingleLine && !hasUnderscores && command.length <= 50) {
-                toolTitle = `_${command}_`;
+            if (isSingleLine && command.length <= 50) {
+                toolTitle = `_${escapeInlineMarkdown(command)}_`;
             }
             else if (description) {
-                toolTitle = `_${description}_`;
+                toolTitle = `_${escapeInlineMarkdown(description)}_`;
             }
             else if (stateTitle) {
-                toolTitle = `_${stateTitle}_`;
+                toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;
             }
         }
         else if (stateTitle) {
-            toolTitle = `_${stateTitle}_`;
+            toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;
         }
         const icon = (() => {
             if (part.state.status === 'error') {

package/dist/message-formatting.test.js

@@ -0,0 +1,73 @@
+import { describe, test, expect } from 'vitest';
+import { formatTodoList } from './message-formatting.js';
+describe('formatTodoList', () => {
+    test('formats active todo with monospace numbers', () => {
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: {
+                    todos: [
+                        { content: 'First task', status: 'completed' },
+                        { content: 'Second task', status: 'in_progress' },
+                        { content: 'Third task', status: 'pending' },
+                    ],
+                },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑵ **second task**"`);
+    });
+    test('formats double digit todo numbers', () => {
+        const todos = Array.from({ length: 12 }, (_, i) => ({
+            content: `Task ${i + 1}`,
+            status: i === 11 ? 'in_progress' : 'completed',
+        }));
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: { todos },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑿ **task 12**"`);
+    });
+    test('lowercases first letter of content', () => {
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: {
+                    todos: [{ content: 'Fix the bug', status: 'in_progress' }],
+                },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑴ **fix the bug**"`);
+    });
+});