kimaki 0.4.44 → 0.4.46

package/dist/session-handler.js

@@ -2,7 +2,7 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
-import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, } from './database.js';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, getChannelVerbosity, } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2, } from './opencode.js';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
@@ -10,7 +10,7 @@ import { getOpencodeSystemMessage } from './system-message.js';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
-import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js';
+import { showPermissionDropdown, cleanupPermissionContext, addPermissionRequestToContext, } from './commands/permissions.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
@@ -20,9 +20,16 @@ export const abortControllers = new Map();
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
 // to avoid duplicates and properly clean up on auto-reject
 export const pendingPermissions = new Map();
+function buildPermissionDedupeKey({ permission, directory, }) {
+    const normalizedPatterns = [...permission.patterns].sort((a, b) => {
+        return a.localeCompare(b);
+    });
+    return `${directory}::${permission.permission}::${normalizedPatterns.join('|')}`;
+}
 // 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);
@@ -56,11 +63,11 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
         sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
         return false;
     }
-    try {
-        await getClient().session.abort({ path: { id: sessionId } });
-    }
-    catch (e) {
-        sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, e);
+    const abortResult = await errore.tryAsync(() => {
+        return getClient().session.abort({ path: { id: sessionId } });
+    });
+    if (abortResult instanceof Error) {
+        sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, abortResult);
     }
     // Small delay to let the abort propagate
     await new Promise((resolve) => {
@@ -82,15 +89,21 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`);
     // Use setImmediate to avoid blocking
     setImmediate(() => {
-        handleOpencodeSession({
-            prompt,
-            thread,
-            projectDirectory,
-            images,
-        }).catch(async (e) => {
-            sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, e);
-            const errorMsg = e instanceof Error ? e.message : String(e);
-            await sendThreadMessage(thread, `✗ Failed to retry with new model: ${errorMsg.slice(0, 200)}`);
+        void errore
+            .tryAsync(async () => {
+            return handleOpencodeSession({
+                prompt,
+                thread,
+                projectDirectory,
+                images,
+            });
+        })
+            .then(async (result) => {
+            if (!(result instanceof Error)) {
+                return;
+            }
+            sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, result);
+            await sendThreadMessage(thread, `✗ Failed to retry with new model: ${result.message.slice(0, 200)}`);
         });
     });
     return true;
@@ -100,6 +113,16 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const sessionStartTime = Date.now();
     const directory = projectDirectory || process.cwd();
     sessionLogger.log(`Using directory: ${directory}`);
+    // Get worktree info early so we can use the correct directory for events and prompts
+    const worktreeInfo = getThreadWorktree(thread.id);
+    const worktreeDirectory = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+        ? worktreeInfo.worktree_directory
+        : undefined;
+    // Use worktree directory for SDK calls if available, otherwise project directory
+    const sdkDirectory = worktreeDirectory || directory;
+    if (worktreeDirectory) {
+        sessionLogger.log(`Using worktree directory for SDK calls: ${worktreeDirectory}`);
+    }
     const getClient = await initializeOpencodeForDirectory(directory);
     if (getClient instanceof Error) {
         await sendThreadMessage(thread, `✗ ${getClient.message}`);
@@ -114,22 +137,26 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let session;
     if (sessionId) {
         sessionLogger.log(`Attempting to reuse existing session ${sessionId}`);
-        try {
-            const sessionResponse = await getClient().session.get({
+        const sessionResponse = await errore.tryAsync(() => {
+            return getClient().session.get({
                 path: { id: sessionId },
+                query: { directory: sdkDirectory },
             });
+        });
+        if (sessionResponse instanceof Error) {
+            voiceLogger.log(`[SESSION] Session ${sessionId} not found, will create new one`);
+        }
+        else {
             session = sessionResponse.data;
             sessionLogger.log(`Successfully reused session ${sessionId}`);
         }
-        catch (error) {
-            voiceLogger.log(`[SESSION] Session ${sessionId} not found, will create new one`);
-        }
     }
     if (!session) {
         const sessionTitle = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt.slice(0, 80);
         voiceLogger.log(`[SESSION] Creating new session with title: "${sessionTitle}"`);
         const sessionResponse = await getClient().session.create({
             body: { title: sessionTitle },
+            query: { directory: sdkDirectory },
         });
         session = sessionResponse.data;
         sessionLogger.log(`Created new session ${session?.id}`);
@@ -150,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);
@@ -157,21 +193,26 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         const clientV2 = getOpencodeClientV2(directory);
         let rejectedCount = 0;
         for (const [permId, pendingPerm] of threadPermissions) {
-            try {
-                sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`);
-                if (clientV2) {
-                    await clientV2.permission.reply({
-                        requestID: permId,
-                        reply: 'reject',
-                    });
-                }
+            sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`);
+            if (!clientV2) {
+                sessionLogger.log(`[PERMISSION] OpenCode v2 client unavailable for permission ${permId}`);
                 cleanupPermissionContext(pendingPerm.contextHash);
                 rejectedCount++;
+                continue;
             }
-            catch (e) {
-                sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, e);
-                cleanupPermissionContext(pendingPerm.contextHash);
+            const rejectResult = await errore.tryAsync(() => {
+                return clientV2.permission.reply({
+                    requestID: permId,
+                    reply: 'reject',
+                });
+            });
+            if (rejectResult instanceof Error) {
+                sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, rejectResult);
             }
+            else {
+                rejectedCount++;
+            }
+            cleanupPermissionContext(pendingPerm.contextHash);
         }
         pendingPermissions.delete(thread.id);
         if (rejectedCount > 0) {
@@ -199,12 +240,22 @@ 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) {
         throw new Error(`OpenCode v2 client not found for directory: ${directory}`);
     }
-    const eventsResult = await clientV2.event.subscribe({ directory }, { signal: abortController.signal });
+    const eventsResult = await clientV2.event.subscribe({ directory: sdkDirectory }, { signal: abortController.signal });
     if (abortController.signal.aborted) {
         sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`);
         return;
@@ -214,7 +265,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const sentPartIds = new Set(getDatabase()
         .prepare('SELECT part_id FROM part_messages WHERE thread_id = ?')
         .all(thread.id).map((row) => row.part_id));
-    let currentParts = [];
+    const partBuffer = new Map();
     let stopTyping = null;
     let usedModel;
     let usedProviderID;
@@ -222,6 +273,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let tokensUsedInSession = 0;
     let lastDisplayedContextPercentage = 0;
     let modelContextLimit;
+    let assistantMessageId;
+    let handlerPromise = null;
     let typingInterval = null;
     function startTyping() {
         if (abortController.signal.aborted) {
@@ -232,12 +285,16 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             clearInterval(typingInterval);
             typingInterval = null;
         }
-        thread.sendTyping().catch((e) => {
-            discordLogger.log(`Failed to send initial typing: ${e}`);
+        void errore.tryAsync(() => thread.sendTyping()).then((result) => {
+            if (result instanceof Error) {
+                discordLogger.log(`Failed to send initial typing: ${result}`);
+            }
         });
         typingInterval = setInterval(() => {
-            thread.sendTyping().catch((e) => {
-                discordLogger.log(`Failed to send periodic typing: ${e}`);
+            void errore.tryAsync(() => thread.sendTyping()).then((result) => {
+                if (result instanceof Error) {
+                    discordLogger.log(`Failed to send periodic typing: ${result}`);
+                }
             });
         }, 8000);
         if (!abortController.signal.aborted) {
@@ -255,7 +312,14 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         };
     }
+    // Get verbosity setting for this channel (use parent channel for threads)
+    const verbosityChannelId = channelId || thread.parentId || thread.id;
+    const verbosity = getChannelVerbosity(verbosityChannelId);
     const sendPartMessage = async (part) => {
+        // In text-only mode, only send text parts (the ⬥ diamond messages)
+        if (verbosity === 'text-only' && part.type !== 'text') {
+            return;
+        }
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
             // discordLogger.log(`SKIP: Part ${part.id} has no content`)
@@ -264,351 +328,443 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         if (sentPartIds.has(part.id)) {
             return;
         }
-        try {
-            const firstMessage = await sendThreadMessage(thread, content);
-            sentPartIds.add(part.id);
-            getDatabase()
-                .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
-                .run(part.id, firstMessage.id, thread.id);
-        }
-        catch (error) {
-            discordLogger.error(`ERROR: Failed to send part ${part.id}:`, error);
+        const sendResult = await errore.tryAsync(() => {
+            return sendThreadMessage(thread, content);
+        });
+        if (sendResult instanceof Error) {
+            discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult);
+            return;
         }
+        sentPartIds.add(part.id);
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
+            .run(part.id, sendResult.id, thread.id);
     };
     const eventHandler = async () => {
         // Subtask tracking: child sessionId → { label, assistantMessageId }
         const subtaskSessions = new Map();
         // Counts spawned tasks per agent type: "explore" → 2
         const agentSpawnCounts = {};
-        try {
-            let assistantMessageId;
-            for await (const event of events) {
-                if (event.type === 'message.updated') {
-                    const msg = event.properties.info;
-                    // Track assistant message IDs for subtask sessions
-                    const subtaskInfo = subtaskSessions.get(msg.sessionID);
-                    if (subtaskInfo && msg.role === 'assistant') {
-                        subtaskInfo.assistantMessageId = msg.id;
-                    }
-                    if (msg.sessionID !== session.id) {
-                        continue;
-                    }
-                    if (msg.role === 'assistant') {
-                        const newTokensTotal = msg.tokens.input +
-                            msg.tokens.output +
-                            msg.tokens.reasoning +
-                            msg.tokens.cache.read +
-                            msg.tokens.cache.write;
-                        if (newTokensTotal > 0) {
-                            tokensUsedInSession = newTokensTotal;
-                        }
-                        assistantMessageId = msg.id;
-                        usedModel = msg.modelID;
-                        usedProviderID = msg.providerID;
-                        usedAgent = msg.mode;
-                        if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
-                            if (!modelContextLimit) {
-                                try {
-                                    const providersResponse = await getClient().provider.list({
-                                        query: { directory },
-                                    });
-                                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
-                                    const model = provider?.models?.[usedModel];
-                                    if (model?.limit?.context) {
-                                        modelContextLimit = model.limit.context;
-                                    }
-                                }
-                                catch (e) {
-                                    sessionLogger.error('Failed to fetch provider info for context limit:', e);
-                                }
-                            }
-                            if (modelContextLimit) {
-                                const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100);
-                                const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
-                                if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
-                                    lastDisplayedContextPercentage = thresholdCrossed;
-                                    const chunk = `⬦ context usage ${currentPercentage}%`;
-                                    await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
-                                }
-                            }
-                        }
-                    }
+        const storePart = (part) => {
+            const messageParts = partBuffer.get(part.messageID) || new Map();
+            messageParts.set(part.id, part);
+            partBuffer.set(part.messageID, messageParts);
+        };
+        const getBufferedParts = (messageID) => {
+            return Array.from(partBuffer.get(messageID)?.values() ?? []);
+        };
+        const shouldSendPart = ({ part, force }) => {
+            if (part.type === 'step-start' || part.type === 'step-finish') {
+                return false;
+            }
+            if (part.type === 'tool' && part.state.status === 'pending') {
+                return false;
+            }
+            if (!force && part.type === 'text' && !part.time?.end) {
+                return false;
+            }
+            if (!force && part.type === 'tool' && part.state.status === 'completed') {
+                return false;
+            }
+            return true;
+        };
+        const flushBufferedParts = async ({ messageID, force, skipPartId, }) => {
+            if (!messageID) {
+                return;
+            }
+            const parts = getBufferedParts(messageID);
+            for (const part of parts) {
+                if (skipPartId && part.id === skipPartId) {
+                    continue;
                 }
-                else if (event.type === 'message.part.updated') {
-                    const part = event.properties.part;
-                    // Check if this is a subtask event (child session we're tracking)
-                    const subtaskInfo = subtaskSessions.get(part.sessionID);
-                    const isSubtaskEvent = Boolean(subtaskInfo);
-                    // Accept events from main session OR tracked subtask sessions
-                    if (part.sessionID !== session.id && !isSubtaskEvent) {
-                        continue;
-                    }
-                    // For subtask events, send them immediately with prefix (don't buffer in currentParts)
-                    if (isSubtaskEvent && subtaskInfo) {
-                        // Skip parts that aren't useful to show (step-start, step-finish, pending tools)
-                        if (part.type === 'step-start' || part.type === 'step-finish') {
-                            continue;
-                        }
-                        if (part.type === 'tool' && part.state.status === 'pending') {
-                            continue;
-                        }
-                        // Skip text parts - the outer agent will report the task result anyway
-                        if (part.type === 'text') {
-                            continue;
-                        }
-                        // Only show parts from assistant messages (not user prompts sent to subtask)
-                        // Skip if we haven't seen an assistant message yet, or if this part is from a different message
-                        if (!subtaskInfo.assistantMessageId ||
-                            part.messageID !== subtaskInfo.assistantMessageId) {
-                            continue;
-                        }
-                        const content = formatPart(part, subtaskInfo.label);
-                        if (content.trim() && !sentPartIds.has(part.id)) {
-                            try {
-                                const msg = await sendThreadMessage(thread, content + '\n\n');
-                                sentPartIds.add(part.id);
-                                getDatabase()
-                                    .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
-                                    .run(part.id, msg.id, thread.id);
-                            }
-                            catch (error) {
-                                discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, error);
-                            }
-                        }
-                        continue;
-                    }
-                    // Main session events: require matching assistantMessageId
-                    if (part.messageID !== assistantMessageId) {
-                        continue;
-                    }
-                    const existingIndex = currentParts.findIndex((p) => p.id === part.id);
-                    if (existingIndex >= 0) {
-                        currentParts[existingIndex] = part;
-                    }
-                    else {
-                        currentParts.push(part);
-                    }
-                    if (part.type === 'step-start') {
-                        // Don't start typing if user needs to respond to a question or permission
-                        const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
-                        const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
-                        if (!hasPendingQuestion && !hasPendingPermission) {
-                            stopTyping = startTyping();
-                        }
-                    }
-                    if (part.type === 'tool' && part.state.status === 'running') {
-                        // Flush any pending text/reasoning parts before showing the tool
-                        // This ensures text the LLM generated before the tool call is shown first
-                        for (const p of currentParts) {
-                            if (p.type !== 'step-start' && p.type !== 'step-finish' && p.id !== part.id) {
-                                await sendPartMessage(p);
-                            }
-                        }
-                        await sendPartMessage(part);
-                        // Track task tool and register child session when sessionId is available
-                        if (part.tool === 'task' && !sentPartIds.has(part.id)) {
-                            const description = part.state.input?.description || '';
-                            const agent = part.state.input?.subagent_type || 'task';
-                            const childSessionId = part.state.metadata?.sessionId || '';
-                            if (description && childSessionId) {
-                                agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1;
-                                const label = `${agent}-${agentSpawnCounts[agent]}`;
-                                subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined });
-                                const taskDisplay = `┣ task **${label}** _${description}_`;
-                                await sendThreadMessage(thread, taskDisplay + '\n\n');
-                                sentPartIds.add(part.id);
-                            }
-                        }
-                    }
-                    // Show token usage for completed tools with large output (>5k tokens)
-                    if (part.type === 'tool' && part.state.status === 'completed') {
-                        const output = part.state.output || '';
-                        const outputTokens = Math.ceil(output.length / 4);
-                        const LARGE_OUTPUT_THRESHOLD = 3000;
-                        if (outputTokens >= LARGE_OUTPUT_THRESHOLD) {
-                            const formattedTokens = outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens);
-                            const percentageSuffix = (() => {
-                                if (!modelContextLimit) {
-                                    return '';
-                                }
-                                const pct = (outputTokens / modelContextLimit) * 100;
-                                if (pct < 1) {
-                                    return '';
-                                }
-                                return ` (${pct.toFixed(1)}%)`;
-                            })();
-                            const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
-                            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
-                        }
-                    }
-                    if (part.type === 'reasoning') {
-                        await sendPartMessage(part);
-                    }
-                    // Send text parts when complete (time.end is set)
-                    // Text parts stream incrementally; only send when finished to avoid partial text
-                    if (part.type === 'text' && part.time?.end) {
-                        await sendPartMessage(part);
-                    }
-                    if (part.type === 'step-finish') {
-                        for (const p of currentParts) {
-                            if (p.type !== 'step-start' && p.type !== 'step-finish') {
-                                await sendPartMessage(p);
-                            }
-                        }
-                        setTimeout(() => {
-                            if (abortController.signal.aborted)
-                                return;
-                            // Don't restart typing if user needs to respond to a question or permission
-                            const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
-                            const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
-                            if (hasPendingQuestion || hasPendingPermission)
-                                return;
-                            stopTyping = startTyping();
-                        }, 300);
-                    }
+                if (!shouldSendPart({ part, force })) {
+                    continue;
                 }
-                else if (event.type === 'session.error') {
-                    sessionLogger.error(`ERROR:`, event.properties);
-                    if (event.properties.sessionID === session.id) {
-                        const errorData = event.properties.error;
-                        const errorMessage = errorData?.data?.message || 'Unknown error';
-                        sessionLogger.error(`Sending error to thread: ${errorMessage}`);
-                        await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`);
-                        if (originalMessage) {
-                            try {
-                                await originalMessage.reactions.removeAll();
-                                await originalMessage.react('❌');
-                                voiceLogger.log(`[REACTION] Added error reaction due to session error`);
-                            }
-                            catch (e) {
-                                discordLogger.log(`Could not update reaction:`, e);
-                            }
-                        }
-                    }
-                    else {
-                        voiceLogger.log(`[SESSION ERROR IGNORED] Error for different session (expected: ${session.id}, got: ${event.properties.sessionID})`);
-                    }
-                    break;
+                await sendPartMessage(part);
+            }
+        };
+        const handleMessageUpdated = async (msg) => {
+            const subtaskInfo = subtaskSessions.get(msg.sessionID);
+            if (subtaskInfo && msg.role === 'assistant') {
+                subtaskInfo.assistantMessageId = msg.id;
+            }
+            if (msg.sessionID !== session.id) {
+                return;
+            }
+            if (msg.role !== 'assistant') {
+                return;
+            }
+            if (msg.tokens) {
+                const newTokensTotal = msg.tokens.input +
+                    msg.tokens.output +
+                    msg.tokens.reasoning +
+                    msg.tokens.cache.read +
+                    msg.tokens.cache.write;
+                if (newTokensTotal > 0) {
+                    tokensUsedInSession = newTokensTotal;
                 }
-                else if (event.type === 'permission.asked') {
-                    const permission = event.properties;
-                    if (permission.sessionID !== session.id) {
-                        voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
-                        continue;
-                    }
-                    // Skip if this exact permission ID is already pending (dedupe)
-                    const threadPermissions = pendingPermissions.get(thread.id);
-                    if (threadPermissions?.has(permission.id)) {
-                        sessionLogger.log(`[PERMISSION] Skipping duplicate permission ${permission.id} (already pending)`);
-                        continue;
-                    }
-                    sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
-                    // Stop typing - user needs to respond now, not the bot
-                    if (stopTyping) {
-                        stopTyping();
-                        stopTyping = null;
-                    }
-                    // Show dropdown instead of text message
-                    const { messageId, contextHash } = await showPermissionDropdown({
-                        thread,
-                        permission,
-                        directory,
-                    });
-                    // Track permission in nested map (threadId -> permissionId -> data)
-                    if (!pendingPermissions.has(thread.id)) {
-                        pendingPermissions.set(thread.id, new Map());
-                    }
-                    pendingPermissions.get(thread.id).set(permission.id, {
-                        permission,
-                        messageId,
-                        directory,
-                        contextHash,
+            }
+            assistantMessageId = msg.id;
+            usedModel = msg.modelID;
+            usedProviderID = msg.providerID;
+            usedAgent = msg.mode;
+            await flushBufferedParts({
+                messageID: assistantMessageId,
+                force: false,
+            });
+            if (tokensUsedInSession === 0 || !usedProviderID || !usedModel) {
+                return;
+            }
+            if (!modelContextLimit) {
+                const providersResponse = await errore.tryAsync(() => {
+                    return getClient().provider.list({
+                        query: { directory: sdkDirectory },
                     });
+                });
+                if (providersResponse instanceof Error) {
+                    sessionLogger.error('Failed to fetch provider info for context limit:', providersResponse);
                 }
-                else if (event.type === 'permission.replied') {
-                    const { requestID, reply, sessionID } = event.properties;
-                    if (sessionID !== session.id) {
-                        continue;
+                else {
+                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                    const model = provider?.models?.[usedModel];
+                    if (model?.limit?.context) {
+                        modelContextLimit = model.limit.context;
                     }
-                    sessionLogger.log(`Permission ${requestID} replied with: ${reply}`);
-                    // Clean up the specific permission from nested map
-                    const threadPermissions = pendingPermissions.get(thread.id);
-                    if (threadPermissions) {
-                        const pending = threadPermissions.get(requestID);
-                        if (pending) {
-                            cleanupPermissionContext(pending.contextHash);
-                            threadPermissions.delete(requestID);
-                            // Remove thread entry if no more pending permissions
-                            if (threadPermissions.size === 0) {
-                                pendingPermissions.delete(thread.id);
-                            }
+                }
+            }
+            if (!modelContextLimit) {
+                return;
+            }
+            const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100);
+            const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
+            if (thresholdCrossed <= lastDisplayedContextPercentage || thresholdCrossed < 10) {
+                return;
+            }
+            lastDisplayedContextPercentage = thresholdCrossed;
+            const chunk = `⬦ context usage ${currentPercentage}%`;
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        };
+        const handleMainPart = async (part) => {
+            const isActiveMessage = assistantMessageId ? part.messageID === assistantMessageId : false;
+            const allowEarlyProcessing = !assistantMessageId && part.type === 'tool' && part.state.status === 'running';
+            if (!isActiveMessage && !allowEarlyProcessing) {
+                if (part.type !== 'step-start') {
+                    return;
+                }
+            }
+            if (part.type === 'step-start') {
+                const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
+                const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
+                if (!hasPendingQuestion && !hasPendingPermission) {
+                    stopTyping = startTyping();
+                }
+                return;
+            }
+            if (part.type === 'tool' && part.state.status === 'running') {
+                await flushBufferedParts({
+                    messageID: assistantMessageId || part.messageID,
+                    force: true,
+                    skipPartId: part.id,
+                });
+                await sendPartMessage(part);
+                if (part.tool === 'task' && !sentPartIds.has(part.id)) {
+                    const description = part.state.input?.description || '';
+                    const agent = part.state.input?.subagent_type || 'task';
+                    const childSessionId = part.state.metadata?.sessionId || '';
+                    if (description && childSessionId) {
+                        agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1;
+                        const label = `${agent}-${agentSpawnCounts[agent]}`;
+                        subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined });
+                        // Skip task messages in text-only mode
+                        if (verbosity !== 'text-only') {
+                            const taskDisplay = `┣ task **${label}** _${description}_`;
+                            await sendThreadMessage(thread, taskDisplay + '\n\n');
                         }
+                        sentPartIds.add(part.id);
                     }
                 }
-                else if (event.type === 'question.asked') {
-                    const questionRequest = event.properties;
-                    if (questionRequest.sessionID !== session.id) {
-                        sessionLogger.log(`[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`);
-                        continue;
-                    }
-                    sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
-                    // Stop typing - user needs to respond now, not the bot
-                    if (stopTyping) {
-                        stopTyping();
-                        stopTyping = null;
-                    }
-                    // Flush any pending text/reasoning parts before showing the dropdown
-                    // This ensures text the LLM generated before the question tool is shown first
-                    for (const p of currentParts) {
-                        if (p.type !== 'step-start' && p.type !== 'step-finish') {
-                            await sendPartMessage(p);
+                return;
+            }
+            if (part.type === 'tool' && part.state.status === 'completed') {
+                const output = part.state.output || '';
+                const outputTokens = Math.ceil(output.length / 4);
+                const largeOutputThreshold = 3000;
+                if (outputTokens >= largeOutputThreshold) {
+                    const formattedTokens = outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens);
+                    const percentageSuffix = (() => {
+                        if (!modelContextLimit) {
+                            return '';
                         }
-                    }
-                    await showAskUserQuestionDropdowns({
-                        thread,
-                        sessionId: session.id,
-                        directory,
-                        requestId: questionRequest.id,
-                        input: { questions: questionRequest.questions },
-                    });
-                    // Process queued messages if any - queued message will cancel the pending question
-                    const queue = messageQueue.get(thread.id);
-                    if (queue && queue.length > 0) {
-                        const nextMessage = queue.shift();
-                        if (queue.length === 0) {
-                            messageQueue.delete(thread.id);
+                        const pct = (outputTokens / modelContextLimit) * 100;
+                        if (pct < 1) {
+                            return '';
                         }
-                        sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
-                        await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
-                        // handleOpencodeSession will call cancelPendingQuestion, which cancels the dropdown
-                        setImmediate(() => {
-                            handleOpencodeSession({
-                                prompt: nextMessage.prompt,
-                                thread,
-                                projectDirectory: directory,
-                                images: nextMessage.images,
-                                channelId,
-                            }).catch(async (e) => {
-                                sessionLogger.error(`[QUEUE] Failed to process queued message:`, e);
-                                const errorMsg = e instanceof Error ? e.message : String(e);
-                                await sendThreadMessage(thread, `✗ Queued message failed: ${errorMsg.slice(0, 200)}`);
-                            });
-                        });
-                    }
+                        return ` (${pct.toFixed(1)}%)`;
+                    })();
+                    const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
+                    await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
                 }
-                else if (event.type === 'session.idle') {
-                    const idleSessionId = event.properties.sessionID;
-                    // Session is done processing - abort to signal completion
-                    if (idleSessionId === session.id) {
-                        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
-                        abortController.abort('finished');
-                    }
-                    else if (subtaskSessions.has(idleSessionId)) {
-                        // Child session completed - clean up tracking
-                        const subtask = subtaskSessions.get(idleSessionId);
-                        sessionLogger.log(`[SUBTASK IDLE] Subtask "${subtask?.label}" completed`);
-                        subtaskSessions.delete(idleSessionId);
-                    }
+            }
+            if (part.type === 'reasoning') {
+                await sendPartMessage(part);
+                return;
+            }
+            if (part.type === 'text' && part.time?.end) {
+                await sendPartMessage(part);
+                return;
+            }
+            if (part.type === 'step-finish') {
+                await flushBufferedParts({
+                    messageID: assistantMessageId || part.messageID,
+                    force: true,
+                });
+                setTimeout(() => {
+                    if (abortController.signal.aborted)
+                        return;
+                    const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
+                    const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
+                    if (hasPendingQuestion || hasPendingPermission)
+                        return;
+                    stopTyping = startTyping();
+                }, 300);
+            }
+        };
+        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;
+            }
+            if (part.type === 'tool' && part.state.status === 'pending') {
+                return;
+            }
+            if (part.type === 'text') {
+                return;
+            }
+            if (!subtaskInfo.assistantMessageId || part.messageID !== subtaskInfo.assistantMessageId) {
+                return;
+            }
+            const content = formatPart(part, subtaskInfo.label);
+            if (!content.trim() || sentPartIds.has(part.id)) {
+                return;
+            }
+            const sendResult = await errore.tryAsync(() => {
+                return sendThreadMessage(thread, content + '\n\n');
+            });
+            if (sendResult instanceof Error) {
+                discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, sendResult);
+                return;
+            }
+            sentPartIds.add(part.id);
+            getDatabase()
+                .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
+                .run(part.id, sendResult.id, thread.id);
+        };
+        const handlePartUpdated = async (part) => {
+            storePart(part);
+            const subtaskInfo = subtaskSessions.get(part.sessionID);
+            const isSubtaskEvent = Boolean(subtaskInfo);
+            if (part.sessionID !== session.id && !isSubtaskEvent) {
+                return;
+            }
+            if (isSubtaskEvent && subtaskInfo) {
+                await handleSubtaskPart(part, subtaskInfo);
+                return;
+            }
+            await handleMainPart(part);
+        };
+        const handleSessionError = async ({ sessionID, error, }) => {
+            if (!sessionID || sessionID !== session.id) {
+                voiceLogger.log(`[SESSION ERROR IGNORED] Error for different session (expected: ${session.id}, got: ${sessionID})`);
+                return;
+            }
+            const errorMessage = error?.data?.message || 'Unknown error';
+            sessionLogger.error(`Sending error to thread: ${errorMessage}`);
+            await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`);
+            if (!originalMessage) {
+                return;
+            }
+            const reactionResult = await errore.tryAsync(async () => {
+                await originalMessage.reactions.removeAll();
+                await originalMessage.react('❌');
+            });
+            if (reactionResult instanceof Error) {
+                discordLogger.log(`Could not update reaction:`, reactionResult);
+            }
+            else {
+                voiceLogger.log(`[REACTION] Added error reaction due to session error`);
+            }
+        };
+        const handlePermissionAsked = async (permission) => {
+            if (permission.sessionID !== session.id) {
+                voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
+                return;
+            }
+            const dedupeKey = buildPermissionDedupeKey({ permission, directory });
+            const threadPermissions = pendingPermissions.get(thread.id);
+            const existingPending = threadPermissions
+                ? Array.from(threadPermissions.values()).find((pending) => {
+                    return pending.dedupeKey === dedupeKey;
+                })
+                : undefined;
+            if (existingPending) {
+                sessionLogger.log(`[PERMISSION] Deduped permission ${permission.id} (matches pending ${existingPending.permission.id})`);
+                if (stopTyping) {
+                    stopTyping();
+                    stopTyping = null;
+                }
+                if (!pendingPermissions.has(thread.id)) {
+                    pendingPermissions.set(thread.id, new Map());
+                }
+                pendingPermissions.get(thread.id).set(permission.id, {
+                    permission,
+                    messageId: existingPending.messageId,
+                    directory,
+                    contextHash: existingPending.contextHash,
+                    dedupeKey,
+                });
+                const added = addPermissionRequestToContext({
+                    contextHash: existingPending.contextHash,
+                    requestId: permission.id,
+                });
+                if (!added) {
+                    sessionLogger.log(`[PERMISSION] Failed to attach duplicate request ${permission.id} to context`);
+                }
+                return;
+            }
+            sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
+            if (stopTyping) {
+                stopTyping();
+                stopTyping = null;
+            }
+            const { messageId, contextHash } = await showPermissionDropdown({
+                thread,
+                permission,
+                directory,
+            });
+            if (!pendingPermissions.has(thread.id)) {
+                pendingPermissions.set(thread.id, new Map());
+            }
+            pendingPermissions.get(thread.id).set(permission.id, {
+                permission,
+                messageId,
+                directory,
+                contextHash,
+                dedupeKey,
+            });
+        };
+        const handlePermissionReplied = ({ requestID, reply, sessionID, }) => {
+            if (sessionID !== session.id) {
+                return;
+            }
+            sessionLogger.log(`Permission ${requestID} replied with: ${reply}`);
+            const threadPermissions = pendingPermissions.get(thread.id);
+            if (!threadPermissions) {
+                return;
+            }
+            const pending = threadPermissions.get(requestID);
+            if (!pending) {
+                return;
+            }
+            cleanupPermissionContext(pending.contextHash);
+            threadPermissions.delete(requestID);
+            if (threadPermissions.size === 0) {
+                pendingPermissions.delete(thread.id);
+            }
+        };
+        const handleQuestionAsked = async (questionRequest) => {
+            if (questionRequest.sessionID !== session.id) {
+                sessionLogger.log(`[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`);
+                return;
+            }
+            sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+            if (stopTyping) {
+                stopTyping();
+                stopTyping = null;
+            }
+            await flushBufferedParts({
+                messageID: assistantMessageId || '',
+                force: true,
+            });
+            await showAskUserQuestionDropdowns({
+                thread,
+                sessionId: session.id,
+                directory,
+                requestId: questionRequest.id,
+                input: { questions: questionRequest.questions },
+            });
+            const queue = messageQueue.get(thread.id);
+            if (!queue || queue.length === 0) {
+                return;
+            }
+            const nextMessage = queue.shift();
+            if (queue.length === 0) {
+                messageQueue.delete(thread.id);
+            }
+            sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
+            await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+            setImmediate(() => {
+                void errore
+                    .tryAsync(async () => {
+                    return handleOpencodeSession({
+                        prompt: nextMessage.prompt,
+                        thread,
+                        projectDirectory: directory,
+                        images: nextMessage.images,
+                        channelId,
+                    });
+                })
+                    .then(async (result) => {
+                    if (!(result instanceof Error)) {
+                        return;
+                    }
+                    sessionLogger.error(`[QUEUE] Failed to process queued message:`, result);
+                    await sendThreadMessage(thread, `✗ Queued message failed: ${result.message.slice(0, 200)}`);
+                });
+            });
+        };
+        const handleSessionIdle = (idleSessionId) => {
+            if (idleSessionId === session.id) {
+                sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
+                abortController.abort('finished');
+                return;
+            }
+            if (!subtaskSessions.has(idleSessionId)) {
+                return;
+            }
+            const subtask = subtaskSessions.get(idleSessionId);
+            sessionLogger.log(`[SUBTASK IDLE] Subtask "${subtask?.label}" completed`);
+            subtaskSessions.delete(idleSessionId);
+        };
+        try {
+            for await (const event of events) {
+                switch (event.type) {
+                    case 'message.updated':
+                        await handleMessageUpdated(event.properties.info);
+                        break;
+                    case 'message.part.updated':
+                        await handlePartUpdated(event.properties.part);
+                        break;
+                    case 'session.error':
+                        sessionLogger.error(`ERROR:`, event.properties);
+                        await handleSessionError(event.properties);
+                        break;
+                    case 'permission.asked':
+                        await handlePermissionAsked(event.properties);
+                        break;
+                    case 'permission.replied':
+                        handlePermissionReplied(event.properties);
+                        break;
+                    case 'question.asked':
+                        await handleQuestionAsked(event.properties);
+                        break;
+                    case 'session.idle':
+                        handleSessionIdle(event.properties.sessionID);
+                        break;
+                    default:
+                        break;
                 }
             }
         }
@@ -621,14 +777,14 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             throw e;
         }
         finally {
-            for (const part of currentParts) {
-                if (!sentPartIds.has(part.id)) {
-                    try {
+            abortControllers.delete(session.id);
+            const finalMessageId = assistantMessageId;
+            if (finalMessageId) {
+                const parts = getBufferedParts(finalMessageId);
+                for (const part of parts) {
+                    if (!sentPartIds.has(part.id)) {
                         await sendPartMessage(part);
                     }
-                    catch (error) {
-                        sessionLogger.error(`Failed to send part ${part.id}:`, error);
-                    }
                 }
             }
             if (stopTyping) {
@@ -641,12 +797,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
                 const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : '';
                 let contextInfo = '';
-                try {
+                const contextResult = await errore.tryAsync(async () => {
                     // Fetch final token count from API since message.updated events can arrive
                     // after session.idle due to race conditions in event ordering
                     if (tokensUsedInSession === 0) {
                         const messagesResponse = await getClient().session.messages({
                             path: { id: session.id },
+                            query: { directory: sdkDirectory },
                         });
                         const messages = messagesResponse.data || [];
                         const lastAssistant = [...messages]
@@ -662,16 +819,16 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                     tokens.cache.write;
                         }
                     }
-                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                    const providersResponse = await getClient().provider.list({ query: { directory: sdkDirectory } });
                     const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
                     const model = provider?.models?.[usedModel || ''];
                     if (model?.limit?.context) {
                         const percentage = Math.round((tokensUsedInSession / model.limit.context) * 100);
                         contextInfo = ` ⋅ ${percentage}%`;
                     }
-                }
-                catch (e) {
-                    sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                });
+                if (contextResult instanceof Error) {
+                    sessionLogger.error('Failed to fetch provider info for context percentage:', contextResult);
                 }
                 await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS });
                 sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
@@ -707,15 +864,20 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         }
     };
-    try {
-        const eventHandlerPromise = eventHandler();
+    const promptResult = await errore.tryAsync(async () => {
+        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;
         }
         stopTyping = startTyping();
         voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
-        // append image paths to prompt so ai knows where they are on disk
         const promptWithImagePaths = (() => {
             if (images.length === 0) {
                 return prompt;
@@ -730,16 +892,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         })();
         const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
         sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
-        // Get agent preference: session-level overrides channel-level
         const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined);
         if (agentPreference) {
             sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
         }
-        // Get model preference: session-level overrides channel-level
-        // BUT: if an agent is set, don't pass model param so the agent's model takes effect
         const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
         const modelParam = (() => {
-            // When an agent is set, let the agent's model config take effect
             if (agentPreference) {
                 sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`);
                 return undefined;
@@ -755,8 +913,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
             return { providerID, modelID };
         })();
-        // Get worktree info if this thread is in a worktree
-        const worktreeInfo = getThreadWorktree(thread.id);
+        // Build worktree info for system message (worktreeInfo was fetched at the start)
         const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
             ? {
                 worktreeDirectory: worktreeInfo.worktree_directory,
@@ -764,10 +921,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 mainRepoDirectory: worktreeInfo.project_directory,
             }
             : undefined;
-        // Use session.command API for slash commands, session.prompt for regular messages
         const response = command
             ? await getClient().session.command({
                 path: { id: session.id },
+                query: { directory: sdkDirectory },
                 body: {
                     command: command.name,
                     arguments: command.arguments,
@@ -777,6 +934,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             })
             : await getClient().session.prompt({
                 path: { id: session.id },
+                query: { directory: sdkDirectory },
                 body: {
                     parts,
                     system: getOpencodeSystemMessage({ sessionId: session.id, channelId, worktree }),
@@ -803,41 +961,50 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
         if (originalMessage) {
-            try {
+            const reactionResult = await errore.tryAsync(async () => {
                 await originalMessage.reactions.removeAll();
                 await originalMessage.react('✅');
-            }
-            catch (e) {
-                discordLogger.log(`Could not update reactions:`, e);
+            });
+            if (reactionResult instanceof Error) {
+                discordLogger.log(`Could not update reactions:`, reactionResult);
             }
         }
         return { sessionID: session.id, result: response.data, port };
+    });
+    if (handlerPromise) {
+        await Promise.race([
+            handlerPromise,
+            new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            }),
+        ]);
     }
-    catch (error) {
-        if (!isAbortError(error, abortController.signal)) {
-            sessionLogger.error(`ERROR: Failed to send prompt:`, error);
-            abortController.abort('error');
-            if (originalMessage) {
-                try {
-                    await originalMessage.reactions.removeAll();
-                    await originalMessage.react('❌');
-                    discordLogger.log(`Added error reaction to message`);
-                }
-                catch (e) {
-                    discordLogger.log(`Could not update reaction:`, e);
-                }
-            }
-            const errorDisplay = (() => {
-                if (error instanceof Error) {
-                    const name = error.constructor.name || 'Error';
-                    return `[${name}]\n${error.stack || error.message}`;
-                }
-                if (typeof error === 'string') {
-                    return error;
-                }
-                return String(error);
-            })();
-            await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`);
+    if (!errore.isError(promptResult)) {
+        return promptResult;
+    }
+    const promptError = promptResult instanceof Error ? promptResult : new Error('Unknown error');
+    if (isAbortError(promptError, abortController.signal)) {
+        return;
+    }
+    sessionLogger.error(`ERROR: Failed to send prompt:`, promptError);
+    abortController.abort('error');
+    if (originalMessage) {
+        const reactionResult = await errore.tryAsync(async () => {
+            await originalMessage.reactions.removeAll();
+            await originalMessage.react('❌');
+        });
+        if (reactionResult instanceof Error) {
+            discordLogger.log(`Could not update reaction:`, reactionResult);
+        }
+        else {
+            discordLogger.log(`Added error reaction to message`);
         }
     }
+    const errorDisplay = (() => {
+        const promptErrorValue = promptError;
+        const name = promptErrorValue.name || 'Error';
+        const message = promptErrorValue.stack || promptErrorValue.message;
+        return `[${name}]\n${message}`;
+    })();
+    await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`);
 }