kimaki 0.4.39 → 0.4.41

package/dist/database.js

@@ -18,7 +18,7 @@ export function getDatabase() {
             },
             catch: (e) => e,
         });
-        if (errore.isError(mkdirError)) {
+        if (mkdirError instanceof Error) {
             dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message);
         }
         const dbPath = path.join(dataDir, 'discord-sessions.db');
@@ -75,6 +75,19 @@ export function getDatabase() {
         xai_api_key TEXT,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        // Track worktrees created for threads (for /new-worktree command)
+        // status: 'pending' while creating, 'ready' when done, 'error' if failed
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_worktrees (
+        thread_id TEXT PRIMARY KEY,
+        worktree_name TEXT NOT NULL,
+        worktree_directory TEXT,
+        project_directory TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
     `);
         runModelMigrations(db);
     }
@@ -202,6 +215,41 @@ export function setSessionAgent(sessionId, agentName) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`).run(sessionId, agentName);
 }
+/**
+ * Get the worktree info for a thread.
+ */
+export function getThreadWorktree(threadId) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM thread_worktrees WHERE thread_id = ?').get(threadId);
+}
+/**
+ * Create a pending worktree entry for a thread.
+ */
+export function createPendingWorktree({ threadId, worktreeName, projectDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO thread_worktrees (thread_id, worktree_name, project_directory, status) VALUES (?, ?, ?, 'pending')`).run(threadId, worktreeName, projectDirectory);
+}
+/**
+ * Mark a worktree as ready with its directory.
+ */
+export function setWorktreeReady({ threadId, worktreeDirectory, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET worktree_directory = ?, status = 'ready' WHERE thread_id = ?`).run(worktreeDirectory, threadId);
+}
+/**
+ * Mark a worktree as failed with error message.
+ */
+export function setWorktreeError({ threadId, errorMessage, }) {
+    const db = getDatabase();
+    db.prepare(`UPDATE thread_worktrees SET status = 'error', error_message = ? WHERE thread_id = ?`).run(errorMessage, threadId);
+}
+/**
+ * Delete the worktree info for a thread.
+ */
+export function deleteThreadWorktree(threadId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,7 +1,7 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { getDatabase, closeDatabase } from './database.js';
+import { getDatabase, closeDatabase, getThreadWorktree } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { getOpencodeSystemMessage } from './system-message.js';
@@ -22,7 +22,10 @@ import * as errore from 'errore';
 import { extractTagsArrays } from './xml.js';
 import { createLogger } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+// Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
+// Each session's event.subscribe() holds a connection; without enough connections,
+// regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 export async function createDiscordClient() {
@@ -94,7 +97,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     try: () => message.fetch(),
                     catch: (e) => e,
                 });
-                if (errore.isError(fetched)) {
+                if (fetched instanceof Error) {
                     discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                     return;
                 }
@@ -132,6 +135,28 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
                     channelAppId = extracted['kimaki.app']?.[0]?.trim();
                 }
+                // Check if this thread is a worktree thread
+                const worktreeInfo = getThreadWorktree(thread.id);
+                if (worktreeInfo) {
+                    if (worktreeInfo.status === 'pending') {
+                        await message.reply({
+                            content: '⏳ Worktree is still being created. Please wait...',
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.status === 'error') {
+                        await message.reply({
+                            content: `❌ Worktree creation failed: ${worktreeInfo.error_message}`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (worktreeInfo.worktree_directory) {
+                        projectDirectory = worktreeInfo.worktree_directory;
+                        discordLogger.log(`Using worktree directory: ${projectDirectory}`);
+                    }
+                }
                 if (channelAppId && channelAppId !== currentAppId) {
                     voiceLogger.log(`[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
                     return;
@@ -175,7 +200,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-                        if (errore.isError(getClient)) {
+                        if (getClient instanceof Error) {
                             voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message);
                             throw new Error(getClient.message);
                         }

package/dist/discord-utils.js

@@ -8,6 +8,9 @@ import { formatMarkdownTables } from './format-tables.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
+import mime from 'mime';
+import fs from 'node:fs';
+import path from 'node:path';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
 // Same as SILENT but without SuppressNotifications - triggers badge/notification
@@ -244,3 +247,36 @@ export function getKimakiMetadata(textChannel) {
     const channelAppId = extracted['kimaki.app']?.[0]?.trim();
     return { projectDirectory, channelAppId };
 }
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+    if (files.length === 0) {
+        return;
+    }
+    // Build attachments array for all files
+    const attachments = files.map((file, index) => ({
+        id: index,
+        filename: path.basename(file),
+    }));
+    const formData = new FormData();
+    formData.append('payload_json', JSON.stringify({ attachments }));
+    // Append each file with its array index, with correct MIME type for grid display
+    files.forEach((file, index) => {
+        const buffer = fs.readFileSync(file);
+        const mimeType = mime.getType(file) || 'application/octet-stream';
+        formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file));
+    });
+    const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bot ${botToken}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord API error: ${response.status} - ${error}`);
+    }
+}

package/dist/errors.js

@@ -1,110 +1,109 @@
 // TaggedError definitions for type-safe error handling with errore.
 // Errors are grouped by category: infrastructure, domain, and validation.
 // Use errore.matchError() for exhaustive error handling in command handlers.
-import * as errore from 'errore';
+import { createTaggedError } from 'errore';
 // ═══════════════════════════════════════════════════════════════════════════
 // INFRASTRUCTURE ERRORS - Server, filesystem, external services
 // ═══════════════════════════════════════════════════════════════════════════
-export class DirectoryNotAccessibleError extends errore.TaggedError('DirectoryNotAccessibleError')() {
-    constructor(args) {
-        super({ ...args, message: `Directory does not exist or is not accessible: ${args.directory}` });
-    }
-}
-export class ServerStartError extends errore.TaggedError('ServerStartError')() {
-    constructor(args) {
-        super({ ...args, message: `Server failed to start on port ${args.port}: ${args.reason}` });
-    }
-}
-export class ServerNotFoundError extends errore.TaggedError('ServerNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `OpenCode server not found for directory: ${args.directory}` });
-    }
-}
-export class ServerNotReadyError extends errore.TaggedError('ServerNotReadyError')() {
-    constructor(args) {
-        super({
-            ...args,
-            message: `OpenCode server for directory "${args.directory}" is in an error state (no client available)`,
-        });
-    }
-}
-export class ApiKeyMissingError extends errore.TaggedError('ApiKeyMissingError')() {
-    constructor(args) {
-        super({ ...args, message: `${args.service} API key is required` });
-    }
+export class DirectoryNotAccessibleError extends createTaggedError({
+    name: 'DirectoryNotAccessibleError',
+    message: 'Directory does not exist or is not accessible: $directory',
+}) {
+}
+export class ServerStartError extends createTaggedError({
+    name: 'ServerStartError',
+    message: 'Server failed to start on port $port: $reason',
+}) {
+}
+export class ServerNotFoundError extends createTaggedError({
+    name: 'ServerNotFoundError',
+    message: 'OpenCode server not found for directory: $directory',
+}) {
+}
+export class ServerNotReadyError extends createTaggedError({
+    name: 'ServerNotReadyError',
+    message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {
+}
+export class ApiKeyMissingError extends createTaggedError({
+    name: 'ApiKeyMissingError',
+    message: '$service API key is required',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // DOMAIN ERRORS - Sessions, messages, transcription
 // ═══════════════════════════════════════════════════════════════════════════
-export class SessionNotFoundError extends errore.TaggedError('SessionNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `Session ${args.sessionId} not found` });
-    }
-}
-export class SessionCreateError extends errore.TaggedError('SessionCreateError')() {
-}
-export class MessagesNotFoundError extends errore.TaggedError('MessagesNotFoundError')() {
-    constructor(args) {
-        super({ ...args, message: `No messages found for session ${args.sessionId}` });
-    }
-}
-export class TranscriptionError extends errore.TaggedError('TranscriptionError')() {
-    constructor(args) {
-        super({ ...args, message: `Transcription failed: ${args.reason}` });
-    }
-}
-export class GrepSearchError extends errore.TaggedError('GrepSearchError')() {
-    constructor(args) {
-        super({ ...args, message: `Grep search failed for pattern: ${args.pattern}` });
-    }
-}
-export class GlobSearchError extends errore.TaggedError('GlobSearchError')() {
-    constructor(args) {
-        super({ ...args, message: `Glob search failed for pattern: ${args.pattern}` });
-    }
+export class SessionNotFoundError extends createTaggedError({
+    name: 'SessionNotFoundError',
+    message: 'Session $sessionId not found',
+}) {
+}
+export class SessionCreateError extends createTaggedError({
+    name: 'SessionCreateError',
+    message: '$message',
+}) {
+}
+export class MessagesNotFoundError extends createTaggedError({
+    name: 'MessagesNotFoundError',
+    message: 'No messages found for session $sessionId',
+}) {
+}
+export class TranscriptionError extends createTaggedError({
+    name: 'TranscriptionError',
+    message: 'Transcription failed: $reason',
+}) {
+}
+export class GrepSearchError extends createTaggedError({
+    name: 'GrepSearchError',
+    message: 'Grep search failed for pattern: $pattern',
+}) {
+}
+export class GlobSearchError extends createTaggedError({
+    name: 'GlobSearchError',
+    message: 'Glob search failed for pattern: $pattern',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // VALIDATION ERRORS - Input validation, format checks
 // ═══════════════════════════════════════════════════════════════════════════
-export class InvalidAudioFormatError extends errore.TaggedError('InvalidAudioFormatError')() {
-    constructor() {
-        super({ message: 'Invalid audio format' });
-    }
-}
-export class EmptyTranscriptionError extends errore.TaggedError('EmptyTranscriptionError')() {
-    constructor() {
-        super({ message: 'Model returned empty transcription' });
-    }
-}
-export class NoResponseContentError extends errore.TaggedError('NoResponseContentError')() {
-    constructor() {
-        super({ message: 'No response content from model' });
-    }
-}
-export class NoToolResponseError extends errore.TaggedError('NoToolResponseError')() {
-    constructor() {
-        super({ message: 'No valid tool responses' });
-    }
+export class InvalidAudioFormatError extends createTaggedError({
+    name: 'InvalidAudioFormatError',
+    message: 'Invalid audio format',
+}) {
+}
+export class EmptyTranscriptionError extends createTaggedError({
+    name: 'EmptyTranscriptionError',
+    message: 'Model returned empty transcription',
+}) {
+}
+export class NoResponseContentError extends createTaggedError({
+    name: 'NoResponseContentError',
+    message: 'No response content from model',
+}) {
+}
+export class NoToolResponseError extends createTaggedError({
+    name: 'NoToolResponseError',
+    message: 'No valid tool responses',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // NETWORK ERRORS - Fetch and HTTP
 // ═══════════════════════════════════════════════════════════════════════════
-export class FetchError extends errore.TaggedError('FetchError')() {
-    constructor(args) {
-        const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause);
-        super({ ...args, message: `Fetch failed for ${args.url}: ${causeMsg}` });
-    }
+export class FetchError extends createTaggedError({
+    name: 'FetchError',
+    message: 'Fetch failed for $url',
+}) {
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // API ERRORS - External service responses
 // ═══════════════════════════════════════════════════════════════════════════
-export class DiscordApiError extends errore.TaggedError('DiscordApiError')() {
-    constructor(args) {
-        super({ ...args, message: `Discord API error: ${args.status}${args.body ? ` - ${args.body}` : ''}` });
-    }
-}
-export class OpenCodeApiError extends errore.TaggedError('OpenCodeApiError')() {
-    constructor(args) {
-        super({ ...args, message: `OpenCode API error (${args.status})${args.body ? `: ${args.body}` : ''}` });
-    }
+export class DiscordApiError extends createTaggedError({
+    name: 'DiscordApiError',
+    message: 'Discord API error: $status $body',
+}) {
+}
+export class OpenCodeApiError extends createTaggedError({
+    name: 'OpenCodeApiError',
+    message: 'OpenCode API error ($status): $body',
+}) {
 }

package/dist/genai-worker.js

@@ -103,7 +103,7 @@ async function createAssistantAudioLogStream(guildId, channelId) {
         try: () => mkdir(audioDir, { recursive: true }),
         catch: (e) => e,
     });
-    if (errore.isError(mkdirError)) {
+    if (mkdirError instanceof Error) {
         workerLogger.error(`Failed to create audio log directory:`, mkdirError.message);
         return null;
     }

package/dist/interaction-handler.js

@@ -3,6 +3,7 @@
 // and manages autocomplete, select menu interactions for the bot.
 import { Events } from 'discord.js';
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js';
+import { handleNewWorktreeCommand } from './commands/worktree.js';
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -30,7 +31,7 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     : 'other'}`);
             if (interaction.isAutocomplete()) {
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionAutocomplete({ interaction, appId });
                         return;
                     case 'resume':
@@ -50,9 +51,12 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             if (interaction.isChatInputCommand()) {
                 interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`);
                 switch (interaction.commandName) {
-                    case 'session':
+                    case 'new-session':
                         await handleSessionCommand({ command: interaction, appId });
                         return;
+                    case 'new-worktree':
+                        await handleNewWorktreeCommand({ command: interaction, appId });
+                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;

package/dist/markdown.js

@@ -3,13 +3,17 @@
 // user messages, assistant responses, tool calls, and reasoning blocks.
 // Uses errore for type-safe error handling.
 import * as errore from 'errore';
+import { createTaggedError } from 'errore';
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
 import { createLogger } from './logger.js';
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
 // Generic error for unexpected exceptions in async operations
-class UnexpectedError extends errore.TaggedError('UnexpectedError')() {
+class UnexpectedError extends createTaggedError({
+    name: 'UnexpectedError',
+    message: '$message',
+}) {
 }
 const markdownLogger = createLogger('MARKDOWN');
 export class ShareMarkdown {

package/dist/message-formatting.js

@@ -62,7 +62,7 @@ export async function getTextAttachments(message) {
             try: () => fetch(attachment.url),
             catch: (e) => new FetchError({ url: attachment.url, cause: e }),
         });
-        if (errore.isError(response)) {
+        if (response instanceof Error) {
             return `<attachment filename="${attachment.name}" error="${response.message}" />`;
         }
         if (!response.ok) {
@@ -90,7 +90,7 @@ export async function getFileAttachments(message) {
             try: () => fetch(attachment.url),
             catch: (e) => new FetchError({ url: attachment.url, cause: e }),
         });
-        if (errore.isError(response)) {
+        if (response instanceof Error) {
             logger.error(`Error downloading attachment ${attachment.name}:`, response.message);
             return null;
         }

package/dist/opencode.js

@@ -43,7 +43,7 @@ async function waitForServer(port, maxAttempts = 30) {
                 try: () => fetch(endpoint),
                 catch: (e) => new FetchError({ url: endpoint, cause: e }),
             });
-            if (errore.isError(response)) {
+            if (response instanceof Error) {
                 // Connection refused or other transient errors - continue polling
                 opencodeLogger.debug(`Server polling attempt failed: ${response.message}`);
                 continue;
@@ -80,7 +80,7 @@ export async function initializeOpencodeForDirectory(directory) {
         },
         catch: () => new DirectoryNotAccessibleError({ directory }),
     });
-    if (errore.isError(accessCheck)) {
+    if (accessCheck instanceof Error) {
         return accessCheck;
     }
     const port = await getOpenPort();
@@ -125,7 +125,7 @@ export async function initializeOpencodeForDirectory(directory) {
                 serverRetryCount.set(directory, retryCount + 1);
                 opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
                 initializeOpencodeForDirectory(directory).then((result) => {
-                    if (errore.isError(result)) {
+                    if (result instanceof Error) {
                         opencodeLogger.error(`Failed to restart opencode server:`, result);
                     }
                 });
@@ -139,7 +139,7 @@ export async function initializeOpencodeForDirectory(directory) {
         }
     });
     const waitResult = await waitForServer(port);
-    if (errore.isError(waitResult)) {
+    if (waitResult instanceof Error) {
         // Dump buffered logs on failure
         opencodeLogger.error(`Server failed to start for ${directory}:`);
         for (const line of logBuffer) {

package/dist/session-handler.js

@@ -49,7 +49,7 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     controller.abort('model-change');
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
         return false;
     }
@@ -98,7 +98,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const directory = projectDirectory || process.cwd();
     sessionLogger.log(`Using directory: ${directory}`);
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         await sendThreadMessage(thread, `✗ ${getClient.message}`);
         return;
     }

package/dist/tools.js

@@ -15,7 +15,7 @@ import pc from 'picocolors';
 import { initializeOpencodeForDirectory, getOpencodeSystemMessage } from './discord-bot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
-    if (errore.isError(getClient)) {
+    if (getClient instanceof Error) {
         throw new Error(getClient.message);
     }
     const client = getClient();
@@ -248,7 +248,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         sessionID: sessionId,
                         lastAssistantOnly: true,
                     });
-                    if (errore.isError(markdownResult)) {
+                    if (markdownResult instanceof Error) {
                         throw new Error(markdownResult.message);
                     }
                     return {
@@ -261,7 +261,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     const markdownResult = await markdownRenderer.generate({
                         sessionID: sessionId,
                     });
-                    if (errore.isError(markdownResult)) {
+                    if (markdownResult instanceof Error) {
                         throw new Error(markdownResult.message);
                     }
                     const messages = await getClient().session.messages({

package/dist/voice-handler.js

@@ -326,7 +326,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         try: () => fetch(audioAttachment.url),
         catch: (e) => new FetchError({ url: audioAttachment.url, cause: e }),
     });
-    if (errore.isError(audioResponse)) {
+    if (audioResponse instanceof Error) {
         voiceLogger.error(`Failed to download audio attachment:`, audioResponse.message);
         await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`);
         return null;
@@ -367,7 +367,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         currentSessionContext,
         lastSessionContext,
     });
-    if (errore.isError(transcription)) {
+    if (transcription instanceof Error) {
         const errMsg = errore.matchError(transcription, {
             ApiKeyMissingError: (e) => e.message,
             InvalidAudioFormatError: (e) => e.message,
@@ -398,7 +398,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             if (renamed === null) {
                 voiceLogger.log(`Thread name update timed out`);
             }
-            else if (errore.isError(renamed)) {
+            else if (renamed instanceof Error) {
                 voiceLogger.log(`Could not update thread name:`, renamed.message);
             }
             else {

package/dist/voice.js

@@ -103,7 +103,7 @@ function createToolRunner({ directory }) {
             voiceLogger.log(`Grep search: "${pattern}"`);
             const result = await runGrep({ pattern, directory });
             const output = (() => {
-                if (errore.isError(result)) {
+                if (result instanceof Error) {
                     voiceLogger.error('grep search failed:', result);
                     return 'grep search failed';
                 }
@@ -117,7 +117,7 @@ function createToolRunner({ directory }) {
             voiceLogger.log(`Glob search: "${pattern}"`);
             const result = await runGlob({ pattern, directory });
             const output = (() => {
-                if (errore.isError(result)) {
+                if (result instanceof Error) {
                     voiceLogger.error('glob search failed:', result);
                     return 'glob search failed';
                 }
@@ -145,7 +145,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
         }),
         catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
     });
-    if (errore.isError(initialResponse)) {
+    if (initialResponse instanceof Error) {
         return initialResponse;
     }
     let response = initialResponse;
@@ -233,7 +233,7 @@ export async function runTranscriptionLoop({ genAI, model, initialContents, tool
             }),
             catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
         });
-        if (errore.isError(nextResponse)) {
+        if (nextResponse instanceof Error) {
             return nextResponse;
         }
         response = nextResponse;