kimaki 0.4.45 → 0.4.47

package/dist/database.js

@@ -5,9 +5,9 @@ import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { getDataDir } from './config.js';
-const dbLogger = createLogger('DB');
+const dbLogger = createLogger(LogPrefix.DB);
 let db = null;
 export function getDatabase() {
     if (!db) {

package/dist/discord-bot.js

@@ -22,14 +22,14 @@ export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels,
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // 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');
+const discordLogger = createLogger(LogPrefix.DISCORD);
+const voiceLogger = createLogger(LogPrefix.VOICE);
 export async function createDiscordClient() {
     return new Client({
         intents: [
@@ -309,6 +309,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
                     reason: 'Start Claude session',
                 });
+                // Add user to thread so it appears in their sidebar
+                await thread.members.add(message.author.id);
                 discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
                 // Create worktree if worktrees are enabled (CLI flag OR channel setting)
                 let sessionDirectory = projectDirectory;

package/dist/discord-utils.js

@@ -7,11 +7,11 @@ import { formatMarkdownTables } from './format-tables.js';
 import { getChannelDirectory } from './database.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import mime from 'mime';
 import fs from 'node:fs';
 import path from 'node:path';
-const discordLogger = createLogger('DISCORD');
+const discordLogger = createLogger(LogPrefix.DISCORD);
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
 // Same as SILENT but without SuppressNotifications - triggers badge/notification
 export const NOTIFY_MESSAGE_FLAGS = 4;

package/dist/genai-worker-wrapper.js

@@ -2,9 +2,9 @@
 // Spawns and manages the worker thread, handling message passing for
 // audio input/output, tool call completions, and graceful shutdown.
 import { Worker } from 'node:worker_threads';
-import { createLogger } from './logger.js';
-const genaiWorkerLogger = createLogger('GENAI WORKER');
-const genaiWrapperLogger = createLogger('GENAI WORKER WRAPPER');
+import { createLogger, LogPrefix } from './logger.js';
+const genaiWorkerLogger = createLogger(LogPrefix.GENAI_WORKER);
+const genaiWrapperLogger = createLogger(LogPrefix.GENAI_WORKER);
 export function createGenAIWorker(options) {
     return new Promise((resolve, reject) => {
         const worker = new Worker(new URL('../dist/genai-worker.js', import.meta.url));

package/dist/genai-worker.js

@@ -10,11 +10,11 @@ import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
 import { mkdir } from 'node:fs/promises';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
 }
-const workerLogger = createLogger(`WORKER ${threadId}`);
+const workerLogger = createLogger(`${LogPrefix.WORKER}_${threadId}`);
 workerLogger.log('GenAI worker started');
 // Define sendError early so it can be used by global handlers
 function sendError(error) {

package/dist/genai.js

@@ -3,9 +3,9 @@
 // and manages the assistant's audio output for Discord voice channels.
 import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session } from '@google/genai';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { aiToolToCallableTool } from './ai-tool-to-genai.js';
-const genaiLogger = createLogger('GENAI');
+const genaiLogger = createLogger(LogPrefix.GENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/interaction-handler.js

@@ -12,6 +12,7 @@ import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
 import { handlePermissionSelectMenu } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
+import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
@@ -21,8 +22,8 @@ import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
 import { handleVerbosityCommand } from './commands/verbosity.js';
-import { createLogger } from './logger.js';
-const interactionLogger = createLogger('INTERACTION');
+import { createLogger, LogPrefix } from './logger.js';
+const interactionLogger = createLogger(LogPrefix.INTERACTION);
 export function registerInteractionHandler({ discordClient, appId, }) {
     interactionLogger.log('[REGISTER] Interaction handler registered');
     discordClient.on(Events.InteractionCreate, async (interaction) => {
@@ -85,6 +86,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
+                    case 'compact':
+                        await handleCompactCommand({ command: interaction, appId });
+                        return;
                     case 'share':
                         await handleShareCommand({ command: interaction, appId });
                         return;

package/dist/logger.js

@@ -1,11 +1,49 @@
-// Prefixed logging utility using @clack/prompts.
-// Creates loggers with consistent prefixes for different subsystems
-// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
-import { log } from '@clack/prompts';
+// Prefixed logging utility.
+// Uses picocolors for compact frequent logs (log, info, debug).
+// Uses @clack/prompts only for important events (warn, error) with visual distinction.
+import { log as clackLog } from '@clack/prompts';
 import fs from 'node:fs';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import util from 'node:util';
+import pc from 'picocolors';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    MARKDOWN: 'MARKDOWN',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REMOVE_PROJECT: 'RM_PROJ',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SHARE: 'SHARE',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const isDev = !__dirname.includes('node_modules');
@@ -32,27 +70,37 @@ function writeToFile(level, prefix, args) {
     const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
     fs.appendFileSync(logFilePath, message);
 }
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
 export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
     return {
         log: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.cyan(paddedPrefix), ...args.map(formatArg));
         },
         error: (...args) => {
             writeToFile('ERROR', prefix, args);
-            log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for errors - visually distinct
+            clackLog.error([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         warn: (...args) => {
             writeToFile('WARN', prefix, args);
-            log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for warnings - visually distinct
+            clackLog.warn([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         info: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.blue(paddedPrefix), ...args.map(formatArg));
         },
         debug: (...args) => {
             writeToFile('DEBUG', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.dim(paddedPrefix), ...args.map(formatArg));
         },
     };
 }

package/dist/markdown.js

@@ -7,7 +7,7 @@ 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 { createLogger, LogPrefix } from './logger.js';
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
 // Generic error for unexpected exceptions in async operations
 class UnexpectedError extends createTaggedError({
@@ -15,7 +15,7 @@ class UnexpectedError extends createTaggedError({
     message: '$message',
 }) {
 }
-const markdownLogger = createLogger('MARKDOWN');
+const markdownLogger = createLogger(LogPrefix.MARKDOWN);
 export class ShareMarkdown {
     client;
     constructor(client) {

package/dist/message-formatting.js

@@ -4,10 +4,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { FetchError } from './errors.js';
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
-const logger = createLogger('FORMATTING');
+const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Escapes Discord inline markdown characters so dynamic content
  * doesn't break formatting when wrapped in *, _, **, etc.
@@ -15,6 +15,12 @@ const logger = createLogger('FORMATTING');
 function escapeInlineMarkdown(text) {
     return text.replace(/([*_~|`\\])/g, '\\$1');
 }
+/**
+ * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
+ */
+function normalizeWhitespace(text) {
+    return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ');
+}
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -125,6 +131,61 @@ export function getToolSummaryText(part) {
             ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
             : `(+${added}-${removed})`;
     }
+    if (part.tool === 'apply_patch') {
+        const state = part.state;
+        const rawFiles = state.metadata?.files;
+        const partMetaFiles = part.metadata?.files;
+        const filesList = Array.isArray(rawFiles)
+            ? rawFiles
+            : Array.isArray(partMetaFiles)
+                ? partMetaFiles
+                : [];
+        const summarizeFiles = (files) => {
+            const summarized = files
+                .map((f) => {
+                if (!f) {
+                    return null;
+                }
+                if (typeof f === 'string') {
+                    const fileName = f.split('/').pop() || '';
+                    return fileName ? `*${escapeInlineMarkdown(fileName)}* (+0-0)` : `(+0-0)`;
+                }
+                if (typeof f !== 'object') {
+                    return null;
+                }
+                const file = f;
+                const pathStr = String(file.relativePath || file.filePath || file.path || '');
+                const fileName = pathStr.split('/').pop() || '';
+                const added = typeof file.additions === 'number' ? file.additions : 0;
+                const removed = typeof file.deletions === 'number' ? file.deletions : 0;
+                return fileName
+                    ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
+                    : `(+${added}-${removed})`;
+            })
+                .filter(Boolean)
+                .join(', ');
+            return summarized;
+        };
+        if (filesList.length > 0) {
+            const summarized = summarizeFiles(filesList);
+            if (summarized) {
+                return summarized;
+            }
+        }
+        const outputText = typeof state.output === 'string' ? state.output : '';
+        const outputLines = outputText.split('\n');
+        const updatedIndex = outputLines.findIndex((line) => line.startsWith('Success. Updated the following files:'));
+        if (updatedIndex !== -1) {
+            const fileLines = outputLines.slice(updatedIndex + 1).filter(Boolean);
+            if (fileLines.length > 0) {
+                const summarized = summarizeFiles(fileLines.map((line) => line.replace(/^[AMD]\s+/, '').trim()));
+                if (summarized) {
+                    return summarized;
+                }
+            }
+        }
+        return '';
+    }
     if (part.tool === 'write') {
         const filePath = part.state.input?.filePath || '';
         const content = part.state.input?.content || '';
@@ -175,7 +236,8 @@ export function getToolSummaryText(part) {
         if (value === null || value === undefined)
             return null;
         const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue;
+        const normalized = normalizeWhitespace(stringValue);
+        const truncatedValue = normalized.length > 50 ? normalized.slice(0, 50) + '…' : normalized;
         return `${key}: ${truncatedValue}`;
     })
         .filter(Boolean);
@@ -201,7 +263,7 @@ export function formatTodoList(part) {
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
 export function formatPart(part, prefix) {
-    const pfx = prefix ? `${prefix}: ` : '';
+    const pfx = prefix ? `${prefix} ⋅ ` : '';
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
@@ -278,12 +340,13 @@ export function formatPart(part, prefix) {
             if (part.state.status === 'error') {
                 return '⨯';
             }
-            if (part.tool === 'edit' || part.tool === 'write') {
+            if (part.tool === 'edit' || part.tool === 'write' || part.tool === 'apply_patch') {
                 return '◼︎';
             }
             return '┣';
         })();
-        return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim();
+        const toolParts = [part.tool, toolTitle, summaryText].filter(Boolean).join(' ');
+        return `${icon} ${pfx}${toolParts}`;
     }
     logger.warn('Unknown part type:', part);
     return '';

package/dist/openai-realtime.js

@@ -3,8 +3,8 @@
 // @ts-nocheck
 import { RealtimeClient } from '@openai/realtime-api-beta';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
-const openaiLogger = createLogger('OPENAI');
+import { createLogger, LogPrefix } from './logger.js';
+const openaiLogger = createLogger(LogPrefix.OPENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/opencode.js

@@ -8,9 +8,9 @@ import net from 'node:net';
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
-const opencodeLogger = createLogger('OPENCODE');
+const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 const opencodeServers = new Map();
 const serverRetryCount = new Map();
 async function getOpenPort() {

package/dist/session-handler.js

@@ -7,14 +7,14 @@ import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext, addPermissionRequestToContext, } from './commands/permissions.js';
 import * as errore from 'errore';
-const sessionLogger = createLogger('SESSION');
-const voiceLogger = createLogger('VOICE');
-const discordLogger = createLogger('DISCORD');
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const discordLogger = createLogger(LogPrefix.DISCORD);
 export const abortControllers = new Map();
 // Track multiple pending permissions per thread (keyed by permission ID)
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
@@ -29,6 +29,7 @@ function buildPermissionDedupeKey({ permission, directory, }) {
 // Queue of messages waiting to be sent after current response finishes
 // Key is threadId, value is array of queued messages
 export const messageQueue = new Map();
+const activeEventHandlers = new Map();
 export function addToQueue({ threadId, message, }) {
     const queue = messageQueue.get(threadId) || [];
     queue.push(message);
@@ -55,7 +56,7 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     }
     sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`);
     // Abort with special reason so we don't show "completed" message
-    controller.abort('model-change');
+    controller.abort(new Error('model-change'));
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
@@ -176,6 +177,15 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     if (existingController) {
         voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
         existingController.abort(new Error('New request started'));
+        const abortResult = await errore.tryAsync(() => {
+            return getClient().session.abort({
+                path: { id: session.id },
+                query: { directory: sdkDirectory },
+            });
+        });
+        if (abortResult instanceof Error) {
+            sessionLogger.log(`[ABORT] Server abort failed (may be already done):`, abortResult);
+        }
     }
     // Auto-reject ALL pending permissions for this thread
     const threadPermissions = pendingPermissions.get(thread.id);
@@ -210,10 +220,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             await sendThreadMessage(thread, `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected due to new message`);
         }
     }
-    // Cancel any pending question tool if user sends a new message (silently, no thread message)
-    const questionCancelled = await cancelPendingQuestion(thread.id);
-    if (questionCancelled) {
-        sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`);
+    // Answer any pending question tool with the user's message (silently, no thread message)
+    const questionAnswered = await cancelPendingQuestion(thread.id, prompt);
+    if (questionAnswered) {
+        sessionLogger.log(`[QUESTION] Answered pending question with user message`);
     }
     const abortController = new AbortController();
     abortControllers.set(session.id, abortController);
@@ -230,6 +240,16 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         sessionLogger.log(`[DEBOUNCE] Aborted before subscribe, exiting`);
         return;
     }
+    const previousHandler = activeEventHandlers.get(thread.id);
+    if (previousHandler) {
+        sessionLogger.log(`[EVENT] Waiting for previous handler to finish`);
+        await Promise.race([
+            previousHandler,
+            new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            }),
+        ]);
+    }
     // Use v2 client for event subscription (has proper types for question.asked events)
     const clientV2 = getOpencodeClientV2(directory);
     if (!clientV2) {
@@ -252,8 +272,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let usedAgent;
     let tokensUsedInSession = 0;
     let lastDisplayedContextPercentage = 0;
+    let lastRateLimitDisplayTime = 0;
     let modelContextLimit;
     let assistantMessageId;
+    let handlerPromise = null;
     let typingInterval = null;
     function startTyping() {
         if (abortController.signal.aborted) {
@@ -509,6 +531,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         };
         const handleSubtaskPart = async (part, subtaskInfo) => {
+            // In text-only mode, skip all subtask output (they're tool-related)
+            if (verbosity === 'text-only') {
+                return;
+            }
             if (part.type === 'step-start' || part.type === 'step-finish') {
                 return;
             }
@@ -700,10 +726,44 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 });
             });
         };
+        const handleSessionStatus = async (properties) => {
+            if (properties.sessionID !== session.id) {
+                return;
+            }
+            if (properties.status.type !== 'retry') {
+                return;
+            }
+            // Throttle to once per 10 seconds
+            const now = Date.now();
+            if (now - lastRateLimitDisplayTime < 10_000) {
+                return;
+            }
+            lastRateLimitDisplayTime = now;
+            const { attempt, message, next } = properties.status;
+            const remainingMs = Math.max(0, next - now);
+            const remainingSec = Math.ceil(remainingMs / 1000);
+            const duration = (() => {
+                if (remainingSec < 60) {
+                    return `${remainingSec}s`;
+                }
+                const mins = Math.floor(remainingSec / 60);
+                const secs = remainingSec % 60;
+                return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+            })();
+            const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`;
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        };
         const handleSessionIdle = (idleSessionId) => {
             if (idleSessionId === session.id) {
+                // Ignore stale session.idle events - if we haven't received any content yet
+                // (no assistantMessageId set), this is likely a stale event from before
+                // the prompt was sent or from a previous request's subscription state.
+                if (!assistantMessageId) {
+                    sessionLogger.log(`[SESSION IDLE] Ignoring stale idle event for ${session.id} (no content received yet)`);
+                    return;
+                }
                 sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
-                abortController.abort('finished');
+                abortController.abort(new Error('finished'));
                 return;
             }
             if (!subtaskSessions.has(idleSessionId)) {
@@ -738,6 +798,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     case 'session.idle':
                         handleSessionIdle(event.properties.sessionID);
                         break;
+                    case 'session.status':
+                        await handleSessionStatus(event.properties);
+                        break;
                     default:
                         break;
                 }
@@ -766,7 +829,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 stopTyping();
                 stopTyping = null;
             }
-            if (!abortController.signal.aborted || abortController.signal.reason === 'finished') {
+            const abortReason = abortController.signal.reason?.message;
+            if (!abortController.signal.aborted || abortReason === 'finished') {
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
@@ -835,12 +899,18 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
             }
             else {
-                sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
+                sessionLogger.log(`Session was aborted (reason: ${abortReason}), skipping duration message`);
             }
         }
     };
     const promptResult = await errore.tryAsync(async () => {
-        const eventHandlerPromise = eventHandler();
+        const newHandlerPromise = eventHandler().finally(() => {
+            if (activeEventHandlers.get(thread.id) === newHandlerPromise) {
+                activeEventHandlers.delete(thread.id);
+            }
+        });
+        activeEventHandlers.set(thread.id, newHandlerPromise);
+        handlerPromise = newHandlerPromise;
         if (abortController.signal.aborted) {
             sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`);
             return;
@@ -927,7 +997,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             })();
             throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
         }
-        abortController.abort('finished');
+        abortController.abort(new Error('finished'));
         sessionLogger.log(`Successfully sent prompt, got response`);
         if (originalMessage) {
             const reactionResult = await errore.tryAsync(async () => {
@@ -940,6 +1010,14 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         }
         return { sessionID: session.id, result: response.data, port };
     });
+    if (handlerPromise) {
+        await Promise.race([
+            handlerPromise,
+            new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            }),
+        ]);
+    }
     if (!errore.isError(promptResult)) {
         return promptResult;
     }
@@ -948,7 +1026,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return;
     }
     sessionLogger.error(`ERROR: Failed to send prompt:`, promptError);
-    abortController.abort('error');
+    abortController.abort(new Error('error'));
     if (originalMessage) {
         const reactionResult = await errore.tryAsync(async () => {
             await originalMessage.reactions.removeAll();

package/dist/tools.js

@@ -6,9 +6,9 @@ import { z } from 'zod';
 import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import * as errore from 'errore';
-const toolsLogger = createLogger('TOOLS');
+const toolsLogger = createLogger(LogPrefix.TOOLS);
 import { ShareMarkdown } from './markdown.js';
 import { formatDistanceToNow } from './utils.js';
 import pc from 'picocolors';

package/dist/voice-handler.js

@@ -17,8 +17,8 @@ import { getDatabase } from './database.js';
 import { sendThreadMessage, escapeDiscordFormatting, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { transcribeAudio } from './voice.js';
 import { FetchError } from './errors.js';
-import { createLogger } from './logger.js';
-const voiceLogger = createLogger('VOICE');
+import { createLogger, LogPrefix } from './logger.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
 export const voiceConnections = new Map();
 export function convertToMono16k(buffer) {
     const inputSampleRate = 48000;

package/dist/voice.js

@@ -4,11 +4,11 @@
 // Uses errore for type-safe error handling.
 import { GoogleGenAI, Type } from '@google/genai';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { glob } from 'glob';
 import { ripGrep } from 'ripgrep-js';
 import { ApiKeyMissingError, InvalidAudioFormatError, TranscriptionError, EmptyTranscriptionError, NoResponseContentError, NoToolResponseError, GrepSearchError, GlobSearchError, } from './errors.js';
-const voiceLogger = createLogger('VOICE');
+const voiceLogger = createLogger(LogPrefix.VOICE);
 function runGrep({ pattern, directory }) {
     return errore.tryAsync({
         try: async () => {