shuvmaki 0.4.26

package/dist/voice.js

@@ -0,0 +1,314 @@
+// Audio transcription service using Google Gemini.
+// Transcribes voice messages with code-aware context, using grep/glob tools
+// to verify technical terms, filenames, and function names in the codebase.
+import { GoogleGenAI, Type, } from '@google/genai';
+import { createLogger } from './logger.js';
+import { glob } from 'glob';
+import { ripGrep } from 'ripgrep-js';
+const voiceLogger = createLogger('VOICE');
+async function runGrep({ pattern, directory, }) {
+    try {
+        const results = await ripGrep(directory, {
+            string: pattern,
+            globs: ['!node_modules/**', '!.git/**', '!dist/**', '!build/**'],
+        });
+        if (results.length === 0) {
+            return 'No matches found';
+        }
+        const output = results
+            .slice(0, 10)
+            .map((match) => {
+            return `${match.path.text}:${match.line_number}: ${match.lines.text.trim()}`;
+        })
+            .join('\n');
+        return output.slice(0, 2000);
+    }
+    catch (e) {
+        voiceLogger.error('grep search failed:', e);
+        return 'grep search failed';
+    }
+}
+async function runGlob({ pattern, directory, }) {
+    try {
+        const files = await glob(pattern, {
+            cwd: directory,
+            nodir: false,
+            ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+            maxDepth: 10,
+        });
+        if (files.length === 0) {
+            return 'No files found';
+        }
+        return files.slice(0, 30).join('\n');
+    }
+    catch (error) {
+        return `Glob search failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+}
+const grepToolDeclaration = {
+    name: 'grep',
+    description: 'Search for a pattern in file contents to verify if a technical term, function name, or variable exists in the code. Use this to check if transcribed words match actual code.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The search pattern (case-insensitive). Can be a word, function name, or partial match.',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const globToolDeclaration = {
+    name: 'glob',
+    description: 'Search for files by name pattern. Use this to verify if a filename or directory mentioned in the audio actually exists in the project.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The glob pattern to match files. Examples: "*.ts", "**/*.json", "**/config*", "src/**/*.tsx"',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const transcriptionResultToolDeclaration = {
+    name: 'transcriptionResult',
+    description: 'MANDATORY: You MUST call this tool to complete the task. This is the ONLY way to return results - text responses are ignored. Call this with your transcription, even if imperfect. An imperfect transcription is better than none.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            transcription: {
+                type: Type.STRING,
+                description: 'The final transcription of the audio. MUST be non-empty. If audio is unclear, transcribe your best interpretation. If silent, use "[inaudible audio]".',
+            },
+        },
+        required: ['transcription'],
+    },
+};
+function createToolRunner({ directory, }) {
+    const hasDirectory = directory && directory.trim().length > 0;
+    return async ({ name, args }) => {
+        if (name === 'transcriptionResult') {
+            return {
+                type: 'result',
+                transcription: args?.transcription || '',
+            };
+        }
+        if (name === 'grep' && hasDirectory) {
+            const pattern = args?.pattern || '';
+            voiceLogger.log(`Grep search: "${pattern}"`);
+            const output = await runGrep({ pattern, directory });
+            voiceLogger.log(`Grep result: ${output.slice(0, 100)}...`);
+            return { type: 'toolResponse', name: 'grep', output };
+        }
+        if (name === 'glob' && hasDirectory) {
+            const pattern = args?.pattern || '';
+            voiceLogger.log(`Glob search: "${pattern}"`);
+            const output = await runGlob({ pattern, directory });
+            voiceLogger.log(`Glob result: ${output.slice(0, 100)}...`);
+            return { type: 'toolResponse', name: 'glob', output };
+        }
+        return { type: 'skip' };
+    };
+}
+export async function runTranscriptionLoop({ genAI, model, initialContents, tools, temperature, toolRunner, maxSteps = 10, }) {
+    let response = await genAI.models.generateContent({
+        model,
+        contents: initialContents,
+        config: {
+            temperature,
+            thinkingConfig: {
+                thinkingBudget: 1024,
+            },
+            tools,
+        },
+    });
+    const conversationHistory = [...initialContents];
+    let stepsRemaining = maxSteps;
+    while (true) {
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            const text = response.text?.trim();
+            if (text) {
+                voiceLogger.log(`No parts but got text response: "${text.slice(0, 100)}..."`);
+                return text;
+            }
+            throw new Error('Transcription failed: No response content from model');
+        }
+        const functionCalls = candidate.content.parts.filter((part) => 'functionCall' in part && !!part.functionCall);
+        if (functionCalls.length === 0) {
+            const text = response.text?.trim();
+            if (text) {
+                voiceLogger.log(`No function calls but got text: "${text.slice(0, 100)}..."`);
+                return text;
+            }
+            throw new Error('Transcription failed: Model did not produce a transcription');
+        }
+        conversationHistory.push({
+            role: 'model',
+            parts: candidate.content.parts,
+        });
+        const functionResponseParts = [];
+        for (const part of functionCalls) {
+            const call = part.functionCall;
+            const args = call.args;
+            const result = await toolRunner({ name: call.name || '', args });
+            if (result.type === 'result') {
+                const transcription = result.transcription?.trim() || '';
+                voiceLogger.log(`Transcription result received: "${transcription.slice(0, 100)}..."`);
+                if (!transcription) {
+                    throw new Error('Transcription failed: Model returned empty transcription');
+                }
+                return transcription;
+            }
+            if (result.type === 'toolResponse') {
+                stepsRemaining--;
+                const stepsWarning = (() => {
+                    if (stepsRemaining <= 0) {
+                        return '\n\n[CRITICAL: Tool limit reached. You MUST call transcriptionResult NOW. No more grep/glob allowed. Call transcriptionResult immediately with your best transcription.]';
+                    }
+                    if (stepsRemaining === 1) {
+                        return '\n\n[URGENT: FINAL STEP. You MUST call transcriptionResult NOW. Do NOT call grep or glob. Call transcriptionResult with your transcription immediately.]';
+                    }
+                    if (stepsRemaining <= 3) {
+                        return `\n\n[WARNING: Only ${stepsRemaining} steps remaining. Finish searching soon and call transcriptionResult. Do not wait until the last step.]`;
+                    }
+                    return '';
+                })();
+                functionResponseParts.push({
+                    functionResponse: {
+                        name: result.name,
+                        response: { output: result.output + stepsWarning },
+                    },
+                });
+            }
+        }
+        if (functionResponseParts.length === 0) {
+            throw new Error('Transcription failed: No valid tool responses');
+        }
+        conversationHistory.push({
+            role: 'user',
+            parts: functionResponseParts,
+        });
+        response = await genAI.models.generateContent({
+            model,
+            contents: conversationHistory,
+            config: {
+                temperature,
+                thinkingConfig: {
+                    thinkingBudget: 512,
+                },
+                tools: stepsRemaining <= 0 ? [{ functionDeclarations: [transcriptionResultToolDeclaration] }] : tools,
+            },
+        });
+    }
+}
+export async function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, currentSessionContext, lastSessionContext, }) {
+    try {
+        const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new Error('Gemini API key is required for audio transcription');
+        }
+        const genAI = new GoogleGenAI({ apiKey });
+        let audioBase64;
+        if (typeof audio === 'string') {
+            audioBase64 = audio;
+        }
+        else if (audio instanceof Buffer) {
+            audioBase64 = audio.toString('base64');
+        }
+        else if (audio instanceof Uint8Array) {
+            audioBase64 = Buffer.from(audio).toString('base64');
+        }
+        else if (audio instanceof ArrayBuffer) {
+            audioBase64 = Buffer.from(audio).toString('base64');
+        }
+        else {
+            throw new Error('Invalid audio format');
+        }
+        const languageHint = language ? `The audio is in ${language}.\n\n` : '';
+        // build session context section
+        const sessionContextParts = [];
+        if (lastSessionContext) {
+            sessionContextParts.push(`<last_session>
+${lastSessionContext}
+</last_session>`);
+        }
+        if (currentSessionContext) {
+            sessionContextParts.push(`<current_session>
+${currentSessionContext}
+</current_session>`);
+        }
+        const sessionContextSection = sessionContextParts.length > 0
+            ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
+            : '';
+        const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
+
+CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
+- The transcriptionResult tool is the ONLY way to return results
+- Text responses are completely ignored - only tool calls work
+- You MUST call transcriptionResult even if you run out of tool calls
+- An imperfect transcription is better than no transcription
+- DO NOT end without calling transcriptionResult
+
+This is a software development environment. The speaker is giving instructions to an AI coding assistant. Expect:
+- File paths, function names, CLI commands, package names, API endpoints
+
+RULES:
+1. If audio is unclear, transcribe your best interpretation, interpreting words event with strong accents are present, identifying the accent being used first so you can guess what the words meawn
+2. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
+3. Use the session context below to understand technical terms, file names, function names mentioned
+
+Common corrections (apply without tool calls):
+- "reacked" → "React", "jason" → "JSON", "get hub" → "GitHub", "no JS" → "Node.js", "dacker" → "Docker"
+
+Project file structure:
+<file_tree>
+${prompt}
+</file_tree>
+${sessionContextSection}
+
+REMEMBER: Call "transcriptionResult" tool with your transcription. This is mandatory.
+
+Note: "critique" is a CLI tool for showing diffs in the browser.`;
+        // const hasDirectory = directory && directory.trim().length > 0
+        const tools = [
+            {
+                functionDeclarations: [
+                    transcriptionResultToolDeclaration,
+                    // grep/glob disabled - was causing transcription to hang
+                    // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+                ],
+            },
+        ];
+        const initialContents = [
+            {
+                role: 'user',
+                parts: [
+                    { text: transcriptionPrompt },
+                    {
+                        inlineData: {
+                            data: audioBase64,
+                            mimeType: 'audio/mpeg',
+                        },
+                    },
+                ],
+            },
+        ];
+        const toolRunner = createToolRunner({ directory });
+        return await runTranscriptionLoop({
+            genAI,
+            model: 'gemini-2.5-flash',
+            initialContents,
+            tools,
+            temperature: temperature ?? 0.3,
+            toolRunner,
+        });
+    }
+    catch (error) {
+        voiceLogger.error('Failed to transcribe audio:', error);
+        throw new Error(`Audio transcription failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/worker-types.js

@@ -0,0 +1,4 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
+export {};

package/dist/xml.js

@@ -0,0 +1,92 @@
+// XML/HTML tag content extractor.
+// Parses XML-like tags from strings (e.g., channel topics) to extract
+// Kimaki configuration like directory paths and app IDs.
+import { DomHandler, Parser, ElementType } from 'htmlparser2';
+import { createLogger } from './logger.js';
+const xmlLogger = createLogger('XML');
+export function extractTagsArrays({ xml, tags, }) {
+    const result = {
+        others: [],
+    };
+    // Initialize arrays for each tag
+    tags.forEach((tag) => {
+        result[tag] = [];
+    });
+    try {
+        const handler = new DomHandler((error, dom) => {
+            if (error) {
+                xmlLogger.error('Error parsing XML:', error);
+            }
+            else {
+                const findTags = (nodes, path = []) => {
+                    nodes.forEach((node) => {
+                        if (node.type === ElementType.Tag) {
+                            const element = node;
+                            const currentPath = [...path, element.name];
+                            const pathString = currentPath.join('.');
+                            // Extract content using original string positions
+                            const extractContent = () => {
+                                // Use element's own indices but exclude the tags
+                                if (element.startIndex !== null &&
+                                    element.endIndex !== null) {
+                                    // Extract the full element including tags
+                                    const fullElement = xml.substring(element.startIndex, element.endIndex + 1);
+                                    // Find where content starts (after opening tag)
+                                    const contentStart = fullElement.indexOf('>') + 1;
+                                    // Find where content ends (before this element's closing tag)
+                                    const closingTag = `</${element.name}>`;
+                                    const contentEnd = fullElement.lastIndexOf(closingTag);
+                                    if (contentStart > 0 && contentEnd > contentStart) {
+                                        return fullElement.substring(contentStart, contentEnd);
+                                    }
+                                    return '';
+                                }
+                                return '';
+                            };
+                            // Check both single tag names and nested paths
+                            if (tags.includes(element.name)) {
+                                const content = extractContent();
+                                result[element.name]?.push(content);
+                            }
+                            // Check for nested path matches
+                            if (tags.includes(pathString)) {
+                                const content = extractContent();
+                                result[pathString]?.push(content);
+                            }
+                            if (element.children) {
+                                findTags(element.children, currentPath);
+                            }
+                        }
+                        else if (node.type === ElementType.Text &&
+                            node.parent?.type === ElementType.Root) {
+                            const textNode = node;
+                            if (textNode.data.trim()) {
+                                // console.log('node.parent',node.parent)
+                                result.others?.push(textNode.data.trim());
+                            }
+                        }
+                    });
+                };
+                findTags(dom);
+            }
+        }, {
+            withStartIndices: true,
+            withEndIndices: true,
+            xmlMode: true,
+        });
+        const parser = new Parser(handler, {
+            xmlMode: true,
+            decodeEntities: false,
+        });
+        parser.write(xml);
+        parser.end();
+    }
+    catch (error) {
+        xmlLogger.error('Unexpected error in extractTags:', error);
+    }
+    return result;
+}
+export function extractNonXmlContent(xml) {
+    const result = extractTagsArrays({ xml, tags: [] });
+    return result.others.join('\n');
+}

package/dist/xml.test.js

@@ -0,0 +1,32 @@
+import { describe, test, expect } from 'vitest';
+import { extractNonXmlContent } from './xml.js';
+describe('extractNonXmlContent', () => {
+    test('removes xml tags and returns only text content', () => {
+        const xml = 'Hello <tag>content</tag> world <nested><inner>deep</inner></nested> end';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`
+      "Hello
+      world
+      end"
+    `);
+    });
+    test('handles multiple text segments', () => {
+        const xml = 'Start <a>tag1</a> middle <b>tag2</b> finish';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`
+      "Start
+      middle
+      finish"
+    `);
+    });
+    test('handles only xml without text', () => {
+        const xml = '<root><child>content</child></root>';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`""`);
+    });
+    test('handles only text without xml', () => {
+        const xml = 'Just plain text';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`"Just plain text"`);
+    });
+    test('handles empty string', () => {
+        const xml = '';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`""`);
+    });
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "shuvmaki",
+  "module": "index.ts",
+  "type": "module",
+  "version": "0.4.26",
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "prepublishOnly": "pnpm tsc",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
+  },
+  "repository": "https://github.com/remorses/kimaki",
+  "bin": "bin.js",
+  "files": [
+    "dist",
+    "src",
+    "bin.js"
+  ],
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.12",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^2.0.47",
+    "@clack/prompts": "^0.11.0",
+    "@discordjs/opus": "^0.10.0",
+    "@discordjs/voice": "^0.19.0",
+    "@google/genai": "^1.34.0",
+    "@opencode-ai/sdk": "^1.1.12",
+    "@purinton/resampler": "^1.0.4",
+    "@snazzah/davey": "^0.1.6",
+    "ai": "^5.0.114",
+    "better-sqlite3": "^12.3.0",
+    "cac": "^6.7.14",
+    "discord.js": "^14.16.3",
+    "domhandler": "^5.0.3",
+    "glob": "^13.0.0",
+    "go-try": "^3.0.2",
+    "htmlparser2": "^10.0.0",
+    "js-yaml": "^4.1.0",
+    "marked": "^16.3.0",
+    "picocolors": "^1.1.1",
+    "pretty-ms": "^9.3.0",
+    "prism-media": "^1.3.5",
+    "ripgrep-js": "^3.0.0",
+    "string-dedent": "^3.0.2",
+    "undici": "^7.16.0",
+    "zod": "^4.2.1"
+  }
+}

package/src/__snapshots__/compact-session-context-no-system.md

@@ -0,0 +1,35 @@
+[Assistant]: Still not showing. The session might not have a `system` field and the first assistant message might not have `synthetic: true`. Let me add debug logging to see what's available:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a, newString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 | tail -30, description=run test and check output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=grep -i "session keys\|text parts" tmp/kimaki.log | tail -10, description=check debug output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Assistant]: Session doesn't have a `system` field. Let me fix the debug logging:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          , newString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 && grep -i "text parts" , description=run test and check debug, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Assistant]: I see - the first assistant text part has **no `synthetic` field** (it's `undefined`), and it's only 44 chars. The session doesn't expose the system prompt.
+
+Let me remove debug logging and fix the test:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    // Note: OpenCode SDK doesn't expose system prompt directl
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess, newString=  try {
+    const messagesResponse = await client.session.messages({
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.test.ts, oldString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal, newString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal

package/src/__snapshots__/compact-session-context.md

@@ -0,0 +1,47 @@
+[Tool bash]: command=grep -A5 -B5 "Session" node_modules/@opencode-ai/.ignored_sdk/dist/gen/core/types.gen.d.ts 2>/dev/nu, description=check session types, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Tool read]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, offset=248, limit=35
+[Assistant]: Let me update the code to also look for system role messages and fetch session info:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    const messagesResponse = await client.session.messages({
+      path: { id: sessionId },
+, newString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess
+[Tool bash]: command=pnpm vitest run -u --testNamePattern "getCompactSessionContext", description=run tests to check system prompt, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=head -30 discord/src/__snapshots__/compact-session-context.md, description=check if system prompt is in snapshot
+[Assistant]: Still not showing. The session might not have a `system` field and the first assistant message might not have `synthetic: true`. Let me add debug logging to see what's available:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a, newString=      } else if (messages.length > 0) {
+        // fallback: look for synthetic text part in first a
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 | tail -30, description=run test and check output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Tool bash]: command=grep -i "session keys\|text parts" tmp/kimaki.log | tail -10, description=check debug output, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord
+[Assistant]: Session doesn't have a `system` field. Let me fix the debug logging:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          , newString=          const textParts = (firstAssistant.parts || []).filter((p) => p.type === 'text')
+          
+[Tool bash]: command=pnpm vitest run --testNamePattern "getCompactSessionContext generates" 2>&1 && grep -i "text parts" , description=run test and check debug, workdir=/Users/morse/Documents/GitHub/kimakivoice/discord, timeout=120000
+[Assistant]: I see - the first assistant text part has **no `synthetic` field** (it's `undefined`), and it's only 44 chars. The session doesn't expose the system prompt.
+
+Let me remove debug logging and fix the test:
+
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=    // Get system prompt if requested
+    if (includeSystemPrompt) {
+      // try session.system fie, newString=    // Get system prompt if requested
+    // Note: OpenCode SDK doesn't expose system prompt directl
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.ts, oldString=  try {
+    // fetch session info to get system prompt
+    const sessionResponse = await client.sess, newString=  try {
+    const messagesResponse = await client.session.messages({
+[Tool edit]: filePath=/Users/morse/Documents/GitHub/kimakivoice/discord/src/markdown.test.ts, oldString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal, newString=  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool cal