disunday 1.0.0

package/dist/session-handler.js

@@ -0,0 +1,1436 @@
+// OpenCode session lifecycle manager.
+// 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 fs from 'node:fs';
+import path from 'node:path';
+import { xdgState } from 'xdg-basedir';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, getChannelVerbosity, getChannelTheme, getBotSettings, getChannelDirectory, } 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';
+import { getOpencodeSystemMessage, } from './system-message.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(LogPrefix.SESSION);
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const discordLogger = createLogger(LogPrefix.DISCORD);
+export const abortControllers = new Map();
+export function abortSession(sessionId) {
+    const controller = abortControllers.get(sessionId);
+    if (!controller) {
+        return false;
+    }
+    sessionLogger.log(`[ABORT] reason=user-reaction sessionId=${sessionId}`);
+    controller.abort(new Error('user-abort'));
+    return true;
+}
+// Built-in tools that are hidden in text-and-essential-tools verbosity mode.
+// Essential tools (edits, bash with side effects, todos, tasks, custom MCP tools) are shown; these navigation/read tools are hidden.
+const NON_ESSENTIAL_TOOLS = new Set([
+    'read',
+    'list',
+    'glob',
+    'grep',
+    'todoread',
+    'skill',
+    'question',
+    'webfetch',
+]);
+function isEssentialToolName(toolName) {
+    return !NON_ESSENTIAL_TOOLS.has(toolName);
+}
+function isEssentialToolPart(part) {
+    if (part.type !== 'tool') {
+        return false;
+    }
+    if (!isEssentialToolName(part.tool)) {
+        return false;
+    }
+    if (part.tool === 'bash') {
+        const hasSideEffect = part.state.input?.hasSideEffect;
+        return hasSideEffect !== false;
+    }
+    return true;
+}
+// Track multiple pending permissions per thread (keyed by permission ID)
+// 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);
+    messageQueue.set(threadId, queue);
+    return queue.length;
+}
+export function getQueueLength(threadId) {
+    return messageQueue.get(threadId)?.length || 0;
+}
+export function clearQueue(threadId) {
+    messageQueue.delete(threadId);
+}
+/**
+ * Read user's recent models from OpenCode TUI's state file.
+ * Uses same path as OpenCode: path.join(xdgState, "opencode", "model.json")
+ * Returns all recent models so we can iterate until finding a valid one.
+ * See: opensrc/repos/github.com/sst/opencode/packages/opencode/src/global/index.ts
+ */
+function getRecentModelsFromTuiState() {
+    if (!xdgState) {
+        return [];
+    }
+    // Same path as OpenCode TUI: path.join(Global.Path.state, "model.json")
+    const modelJsonPath = path.join(xdgState, 'opencode', 'model.json');
+    const result = errore.tryFn(() => {
+        const content = fs.readFileSync(modelJsonPath, 'utf-8');
+        const data = JSON.parse(content);
+        return data.recent ?? [];
+    });
+    if (result instanceof Error) {
+        // File doesn't exist or is invalid - this is normal for fresh installs
+        return [];
+    }
+    return result;
+}
+/**
+ * Parse a model string in format "provider/model" into providerID and modelID.
+ */
+function parseModelString(model) {
+    const [providerID, ...modelParts] = model.split('/');
+    const modelID = modelParts.join('/');
+    if (!providerID || !modelID) {
+        return undefined;
+    }
+    return { providerID, modelID };
+}
+/**
+ * Validate that a model is available (provider connected + model exists).
+ */
+function isModelValid(model, connected, providers) {
+    const isConnected = connected.includes(model.providerID);
+    const provider = providers.find((p) => p.id === model.providerID);
+    const modelExists = provider?.models && model.modelID in provider.models;
+    return isConnected && !!modelExists;
+}
+/**
+ * Get the default model from OpenCode when no user preference is set.
+ * Priority (matches OpenCode TUI behavior):
+ * 1. OpenCode config.model setting
+ * 2. User's recent models from TUI state (~/.local/state/opencode/model.json)
+ * 3. First connected provider's default model from API
+ */
+async function getDefaultModel({ getClient, directory, }) {
+    if (getClient instanceof Error) {
+        return undefined;
+    }
+    // Fetch connected providers to validate any model we return
+    const providersResponse = await errore.tryAsync(() => {
+        return getClient().provider.list({ query: { directory } });
+    });
+    if (providersResponse instanceof Error) {
+        sessionLogger.log(`[MODEL] Failed to fetch providers for default model:`, providersResponse.message);
+        return undefined;
+    }
+    if (!providersResponse.data) {
+        return undefined;
+    }
+    const { connected, default: defaults, all: providers, } = providersResponse.data;
+    if (connected.length === 0) {
+        sessionLogger.log(`[MODEL] No connected providers found`);
+        return undefined;
+    }
+    // 1. Check OpenCode config.model setting (highest priority after user preference)
+    const configResponse = await errore.tryAsync(() => {
+        return getClient().config.get({ query: { directory } });
+    });
+    if (!(configResponse instanceof Error) && configResponse.data?.model) {
+        const configModel = parseModelString(configResponse.data.model);
+        if (configModel && isModelValid(configModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`);
+            return configModel;
+        }
+        if (configModel) {
+            sessionLogger.log(`[MODEL] Config model ${configResponse.data.model} not available, checking recent`);
+        }
+    }
+    // 2. Try to use user's recent models from TUI state (iterate until finding valid one)
+    const recentModels = getRecentModelsFromTuiState();
+    for (const recentModel of recentModels) {
+        if (isModelValid(recentModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using recent TUI model: ${recentModel.providerID}/${recentModel.modelID}`);
+            return recentModel;
+        }
+    }
+    if (recentModels.length > 0) {
+        sessionLogger.log(`[MODEL] No valid recent TUI models found`);
+    }
+    // 3. Fall back to first connected provider's default model
+    const firstConnected = connected[0];
+    if (!firstConnected) {
+        return undefined;
+    }
+    const defaultModelId = defaults[firstConnected];
+    if (!defaultModelId) {
+        sessionLogger.log(`[MODEL] No default model for provider ${firstConnected}`);
+        return undefined;
+    }
+    sessionLogger.log(`[MODEL] Using provider default: ${firstConnected}/${defaultModelId}`);
+    return { providerID: firstConnected, modelID: defaultModelId };
+}
+/**
+ * Abort a running session and retry with the last user message.
+ * Used when model preference changes mid-request.
+ * Fetches last user message from OpenCode API instead of tracking in memory.
+ * @returns true if aborted and retry scheduled, false if no active request
+ */
+export async function abortAndRetrySession({ sessionId, thread, projectDirectory, }) {
+    const controller = abortControllers.get(sessionId);
+    if (!controller) {
+        sessionLogger.log(`[ABORT+RETRY] No active request for session ${sessionId}`);
+        return false;
+    }
+    sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`);
+    // Abort with special reason so we don't show "completed" message
+    sessionLogger.log(`[ABORT] reason=model-change sessionId=${sessionId} - user changed model mid-request, will retry with new model`);
+    controller.abort(new Error('model-change'));
+    // Also call the API abort endpoint
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
+        return false;
+    }
+    sessionLogger.log(`[ABORT-API] reason=model-change sessionId=${sessionId} - sending API abort for model change retry`);
+    const abortResult = await errore.tryAsync(() => {
+        return getClient().session.abort({ path: { id: sessionId } });
+    });
+    if (abortResult instanceof Error) {
+        sessionLogger.log(`[ABORT-API] API abort call failed (may already be done):`, abortResult);
+    }
+    // Small delay to let the abort propagate
+    await new Promise((resolve) => {
+        setTimeout(resolve, 300);
+    });
+    // Fetch last user message from API
+    sessionLogger.log(`[ABORT+RETRY] Fetching last user message for session ${sessionId}`);
+    const messagesResponse = await getClient().session.messages({
+        path: { id: sessionId },
+    });
+    const messages = messagesResponse.data || [];
+    const lastUserMessage = [...messages]
+        .reverse()
+        .find((m) => m.info.role === 'user');
+    if (!lastUserMessage) {
+        sessionLogger.log(`[ABORT+RETRY] No user message found in session ${sessionId}`);
+        return false;
+    }
+    // Extract text and images from parts
+    const textPart = lastUserMessage.parts.find((p) => p.type === 'text');
+    const prompt = textPart?.text || '';
+    const images = lastUserMessage.parts.filter((p) => p.type === 'file');
+    sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`);
+    // Use setImmediate to avoid blocking
+    setImmediate(() => {
+        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;
+}
+export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], channelId, command, agent, }) {
+    voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
+    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}`);
+        return;
+    }
+    const serverEntry = getOpencodeServers().get(directory);
+    const port = serverEntry?.port;
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(thread.id);
+    let sessionId = row?.session_id;
+    let session;
+    if (sessionId) {
+        sessionLogger.log(`Attempting to reuse existing session ${sessionId}`);
+        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}`);
+        }
+    }
+    let isNewSession = false;
+    if (!session) {
+        isNewSession = true;
+        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}`);
+    }
+    if (!session) {
+        throw new Error('Failed to create or get session');
+    }
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+        .run(thread.id, session.id);
+    sessionLogger.log(`Stored session ${session.id} for thread ${thread.id}`);
+    if (isNewSession) {
+        const terminalCmd = `opencode -s ${session.id} ${sdkDirectory}`;
+        const sessionInfoContent = `📋 **Session Info**\n**ID:** \`${session.id}\`\n**Terminal:**\n\`\`\`\n${terminalCmd}\n\`\`\``;
+        const infoMessage = await sendThreadMessage(thread, sessionInfoContent);
+        await infoMessage.pin().catch(() => { });
+    }
+    // Store agent preference if provided
+    if (agent) {
+        setSessionAgent(session.id, agent);
+        sessionLogger.log(`Set agent preference for session ${session.id}: ${agent}`);
+    }
+    const existingController = abortControllers.get(session.id);
+    if (existingController) {
+        voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
+        sessionLogger.log(`[ABORT] reason=new-request sessionId=${session.id} threadId=${thread.id} - new user message arrived while previous request was still running`);
+        existingController.abort(new Error('New request started'));
+        sessionLogger.log(`[ABORT-API] reason=new-request sessionId=${session.id} - sending API abort because new message arrived`);
+        const abortResult = await errore.tryAsync(() => {
+            return getClient().session.abort({
+                path: { id: session.id },
+                query: { directory: sdkDirectory },
+            });
+        });
+        if (abortResult instanceof Error) {
+            sessionLogger.log(`[ABORT-API] Server abort failed (may be already done):`, abortResult);
+        }
+    }
+    // Auto-reject ALL pending permissions for this thread
+    const threadPermissions = pendingPermissions.get(thread.id);
+    if (threadPermissions && threadPermissions.size > 0) {
+        const clientV2 = getOpencodeClientV2(directory);
+        let rejectedCount = 0;
+        for (const [permId, pendingPerm] of threadPermissions) {
+            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;
+            }
+            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) {
+            const plural = rejectedCount > 1 ? 's' : '';
+            await sendThreadMessage(thread, `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected 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);
+    if (existingController) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+        if (abortController.signal.aborted) {
+            sessionLogger.log(`[DEBOUNCE] Request was superseded during wait, exiting`);
+            return;
+        }
+    }
+    if (abortController.signal.aborted) {
+        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: sdkDirectory }, { signal: abortController.signal });
+    if (abortController.signal.aborted) {
+        sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`);
+        return;
+    }
+    const events = eventsResult.stream;
+    sessionLogger.log(`Subscribed to OpenCode events`);
+    const sentPartIds = new Set(getDatabase()
+        .prepare('SELECT part_id FROM part_messages WHERE thread_id = ?')
+        .all(thread.id).map((row) => row.part_id));
+    const partBuffer = new Map();
+    let stopTyping = null;
+    let stopProgress = null;
+    let usedModel;
+    let usedProviderID;
+    let usedAgent;
+    let tokensUsedInSession = 0;
+    let lastDisplayedContextPercentage = 0;
+    let lastRateLimitDisplayTime = 0;
+    let modelContextLimit;
+    let assistantMessageId;
+    let handlerPromise = null;
+    let typingInterval = null;
+    let progressInterval = null;
+    let hasSentParts = false;
+    let promptResolved = false;
+    let hasReceivedEvent = false;
+    function startProgressTimer() {
+        if (abortController.signal.aborted) {
+            return () => { };
+        }
+        if (progressInterval) {
+            clearInterval(progressInterval);
+            progressInterval = null;
+        }
+        progressInterval = setInterval(() => {
+            if (abortController.signal.aborted) {
+                if (progressInterval) {
+                    clearInterval(progressInterval);
+                    progressInterval = null;
+                }
+                return;
+            }
+            const elapsed = Date.now() - sessionStartTime;
+            const elapsedSec = Math.floor(elapsed / 1000);
+            const duration = (() => {
+                if (elapsedSec < 60) {
+                    return `${elapsedSec}s`;
+                }
+                const mins = Math.floor(elapsedSec / 60);
+                const secs = elapsedSec % 60;
+                return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+            })();
+            void thread.send({ content: `⏳ Working... (${duration})`, flags: SILENT_MESSAGE_FLAGS });
+        }, 30_000);
+        abortController.signal.addEventListener('abort', () => {
+            if (progressInterval) {
+                clearInterval(progressInterval);
+                progressInterval = null;
+            }
+        }, { once: true });
+        return () => {
+            if (progressInterval) {
+                clearInterval(progressInterval);
+                progressInterval = null;
+            }
+        };
+    }
+    function startTyping() {
+        if (abortController.signal.aborted) {
+            discordLogger.log(`Not starting typing, already aborted`);
+            return () => { };
+        }
+        if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+        }
+        void errore
+            .tryAsync(() => thread.sendTyping())
+            .then((result) => {
+            if (result instanceof Error) {
+                discordLogger.log(`Failed to send initial typing: ${result}`);
+            }
+        });
+        typingInterval = setInterval(() => {
+            void errore
+                .tryAsync(() => thread.sendTyping())
+                .then((result) => {
+                if (result instanceof Error) {
+                    discordLogger.log(`Failed to send periodic typing: ${result}`);
+                }
+            });
+        }, 8000);
+        if (!abortController.signal.aborted) {
+            abortController.signal.addEventListener('abort', () => {
+                if (typingInterval) {
+                    clearInterval(typingInterval);
+                    typingInterval = null;
+                }
+            }, { once: true });
+        }
+        return () => {
+            if (typingInterval) {
+                clearInterval(typingInterval);
+                typingInterval = null;
+            }
+        };
+    }
+    // Read verbosity and theme dynamically so mid-session changes take effect immediately
+    const verbosityChannelId = channelId || thread.parentId || thread.id;
+    const getVerbosity = () => {
+        return getChannelVerbosity(verbosityChannelId);
+    };
+    const getTheme = () => {
+        return getChannelTheme(verbosityChannelId);
+    };
+    const sendPartMessage = async (part) => {
+        const verbosity = getVerbosity();
+        // In text-only mode, only send text parts (the ⬥ diamond messages)
+        if (verbosity === 'text-only' && part.type !== 'text') {
+            return;
+        }
+        // In text-and-essential-tools mode, show text + essential tools (edits, custom MCP tools)
+        if (verbosity === 'text-and-essential-tools') {
+            if (part.type === 'text') {
+                // text is always shown
+            }
+            else if (part.type === 'tool' && isEssentialToolPart(part)) {
+                // essential tools are shown
+            }
+            else {
+                return;
+            }
+        }
+        const content = formatPart(part, undefined, getTheme()) + '\n\n';
+        if (!content.trim() || content.length === 0) {
+            return;
+        }
+        if (sentPartIds.has(part.id)) {
+            return;
+        }
+        const sendResult = await errore.tryAsync(() => {
+            return sendThreadMessage(thread, content);
+        });
+        if (sendResult instanceof Error) {
+            discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult);
+            return;
+        }
+        hasSentParts = true;
+        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 = {};
+        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;
+                }
+                if (!shouldSendPart({ part, force })) {
+                    continue;
+                }
+                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;
+            }
+            hasReceivedEvent = true;
+            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;
+                }
+            }
+            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 {
+                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                    const model = provider?.models?.[usedModel];
+                    if (model?.limit?.context) {
+                        modelContextLimit = model.limit.context;
+                    }
+                }
+            }
+            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,
+                        });
+                        // Show task messages in tools-and-text and text-and-essential-tools modes
+                        if (getVerbosity() !== 'text-only') {
+                            const taskDisplay = `┣ task **${label}** _${description}_`;
+                            await sendThreadMessage(thread, taskDisplay + '\n\n');
+                        }
+                        sentPartIds.add(part.id);
+                    }
+                }
+                return;
+            }
+            // Show large output notifications for tools that are visible in current verbosity mode
+            if (part.type === 'tool' && part.state.status === 'completed') {
+                const showLargeOutput = (() => {
+                    const verbosity = getVerbosity();
+                    if (verbosity === 'text-only') {
+                        return false;
+                    }
+                    if (verbosity === 'text-and-essential-tools') {
+                        return isEssentialToolPart(part);
+                    }
+                    return true;
+                })();
+                if (showLargeOutput) {
+                    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 '';
+                            }
+                            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);
+                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) => {
+            const verbosity = getVerbosity();
+            // In text-only mode, skip all subtask output (they're tool-related)
+            if (verbosity === 'text-only') {
+                return;
+            }
+            // In text-and-essential-tools mode, only show essential tools from subtasks
+            if (verbosity === 'text-and-essential-tools') {
+                if (!isEssentialToolPart(part)) {
+                    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, getTheme());
+            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) => {
+            const isMainSession = permission.sessionID === session.id;
+            const isSubtaskSession = subtaskSessions.has(permission.sessionID);
+            if (!isMainSession && !isSubtaskSession) {
+                voiceLogger.log(`[PERMISSION IGNORED] Permission for unknown session (expected: ${session.id} or subtask, got: ${permission.sessionID})`);
+                return;
+            }
+            const subtaskLabel = isSubtaskSession
+                ? subtaskSessions.get(permission.sessionID)?.label
+                : undefined;
+            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 (stopProgress) {
+                    stopProgress();
+                    stopProgress = 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(', ')}${subtaskLabel ? `, subtask=${subtaskLabel}` : ''}`);
+            if (stopTyping) {
+                stopTyping();
+                stopTyping = null;
+            }
+            if (stopProgress) {
+                stopProgress();
+                stopProgress = null;
+            }
+            const { messageId, contextHash } = await showPermissionDropdown({
+                thread,
+                permission,
+                directory,
+                subtaskLabel,
+            });
+            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, }) => {
+            const isMainSession = sessionID === session.id;
+            const isSubtaskSession = subtaskSessions.has(sessionID);
+            if (!isMainSession && !isSubtaskSession) {
+                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;
+            }
+            if (stopProgress) {
+                stopProgress();
+                stopProgress = 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(() => {
+                const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`;
+                void errore
+                    .tryAsync(async () => {
+                    return handleOpencodeSession({
+                        prompt: prefixedPrompt,
+                        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 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) {
+                if (!promptResolved || !hasReceivedEvent) {
+                    sessionLogger.log(`[SESSION IDLE] Ignoring idle event for ${session.id} (prompt not resolved or no events yet)`);
+                    return;
+                }
+                sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, ending stream`);
+                sessionLogger.log(`[ABORT] reason=finished sessionId=${session.id} threadId=${thread.id} - session completed normally, received idle event after prompt resolved`);
+                abortController.abort(new Error('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) {
+                // Log all events for debugging
+                if (event.type !== 'message.updated' && event.type !== 'message.part.updated') {
+                    sessionLogger.log(`[EVENT] type=${event.type} sessionId=${session.id}`);
+                }
+                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':
+                        sessionLogger.log(`[QUESTION.ASKED] Received question event: ${JSON.stringify(event.properties).slice(0, 500)}`);
+                        await handleQuestionAsked(event.properties);
+                        break;
+                    case 'session.idle':
+                        handleSessionIdle(event.properties.sessionID);
+                        break;
+                    case 'session.status':
+                        await handleSessionStatus(event.properties);
+                        break;
+                    default:
+                        sessionLogger.log(`[EVENT] Unknown event type: ${event.type}`);
+                        break;
+                }
+            }
+        }
+        catch (e) {
+            if (isAbortError(e, abortController.signal)) {
+                sessionLogger.log('AbortController aborted event handling (normal exit)');
+                return;
+            }
+            sessionLogger.error(`Unexpected error in event handling code`, e);
+            throw e;
+        }
+        finally {
+            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);
+                    }
+                }
+            }
+            if (stopTyping) {
+                stopTyping();
+                stopTyping = null;
+            }
+            if (stopProgress) {
+                stopProgress();
+                stopProgress = null;
+            }
+            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}` : '';
+                const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build'
+                    ? ` ⋅ **${usedAgent}**`
+                    : '';
+                let contextInfo = '';
+                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]
+                            .reverse()
+                            .find((m) => m.info.role === 'assistant');
+                        if (lastAssistant && 'tokens' in lastAssistant.info) {
+                            const tokens = lastAssistant.info.tokens;
+                            tokensUsedInSession =
+                                tokens.input +
+                                    tokens.output +
+                                    tokens.reasoning +
+                                    tokens.cache.read +
+                                    tokens.cache.write;
+                        }
+                    }
+                    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}%`;
+                    }
+                });
+                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}`);
+                const channelConfig = getChannelDirectory(channelId || thread.parentId || thread.id);
+                if (channelConfig?.appId) {
+                    await sendHubNotification({
+                        appId: channelConfig.appId,
+                        thread,
+                        directory,
+                        sessionDuration,
+                        contextInfo,
+                        modelInfo,
+                    });
+                }
+                // Process queued messages after completion
+                const queue = messageQueue.get(thread.id);
+                if (queue && queue.length > 0) {
+                    const nextMessage = queue.shift();
+                    if (queue.length === 0) {
+                        messageQueue.delete(thread.id);
+                    }
+                    sessionLogger.log(`[QUEUE] Processing queued message from ${nextMessage.username}`);
+                    // Show that queued message is being sent
+                    await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+                    // Send the queued message as a new prompt (recursive call)
+                    // Use setImmediate to avoid blocking and allow this finally to complete
+                    setImmediate(() => {
+                        const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`;
+                        handleOpencodeSession({
+                            prompt: prefixedPrompt,
+                            thread,
+                            projectDirectory,
+                            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)}`);
+                        });
+                    });
+                }
+            }
+            else {
+                sessionLogger.log(`Session was aborted (reason: ${abortReason}), skipping duration message`);
+            }
+        }
+    };
+    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();
+        stopProgress = startProgressTimer();
+        voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+        const promptWithImagePaths = (() => {
+            if (images.length === 0) {
+                return prompt;
+            }
+            sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({
+                mime: img.mime,
+                filename: img.filename,
+                sourceUrl: img.sourceUrl,
+            })));
+            // List source URLs and clarify these images are already in context (not paths to read)
+            const imageList = images
+                .map((img) => `- ${img.sourceUrl || img.filename}`)
+                .join('\n');
+            return `${prompt}\n\n**The following images are already included in this message as inline content (do not use Read tool on these):**\n${imageList}`;
+        })();
+        const parts = [
+            { type: 'text', text: promptWithImagePaths },
+            ...images,
+        ];
+        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+        const agentPreference = getSessionAgent(session.id) ||
+            (channelId ? getChannelAgent(channelId) : undefined);
+        if (agentPreference) {
+            sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
+        }
+        // Model priority: session model > agent model > channel model > default
+        const sessionModelPreference = getSessionModel(session.id);
+        const channelModelPreference = channelId
+            ? getChannelModel(channelId)
+            : undefined;
+        const modelParam = await (async () => {
+            // 1. Session model preference (highest priority, explicit user override)
+            if (sessionModelPreference) {
+                const [providerID, ...modelParts] = sessionModelPreference.split('/');
+                const modelID = modelParts.join('/');
+                if (providerID && modelID) {
+                    sessionLogger.log(`[MODEL] Using session preference: ${sessionModelPreference}`);
+                    return { providerID, modelID };
+                }
+            }
+            // 2. Agent's configured model
+            if (agentPreference) {
+                const agentsResponse = await errore.tryAsync(() => {
+                    return getClient().app.agents({ query: { directory: sdkDirectory } });
+                });
+                if (!(agentsResponse instanceof Error) && agentsResponse.data) {
+                    const agent = agentsResponse.data.find((a) => a.name === agentPreference);
+                    if (agent?.model) {
+                        sessionLogger.log(`[MODEL] Using agent model: ${agent.model.providerID}/${agent.model.modelID}`);
+                        return agent.model;
+                    }
+                    sessionLogger.log(`[MODEL] Agent "${agentPreference}" has no model configured`);
+                }
+            }
+            // 3. Channel model preference
+            if (channelModelPreference) {
+                const [providerID, ...modelParts] = channelModelPreference.split('/');
+                const modelID = modelParts.join('/');
+                if (providerID && modelID) {
+                    sessionLogger.log(`[MODEL] Using channel preference: ${channelModelPreference}`);
+                    return { providerID, modelID };
+                }
+            }
+            // 4. Default model from OpenCode (like TUI does)
+            const defaultModel = await getDefaultModel({
+                getClient,
+                directory: sdkDirectory,
+            });
+            if (defaultModel) {
+                sessionLogger.log(`[MODEL] Using default: ${defaultModel.providerID}/${defaultModel.modelID}`);
+                return defaultModel;
+            }
+            // No model available - this will likely cause an error from OpenCode
+            sessionLogger.log(`[MODEL] No model available (no preference, no default)`);
+            return undefined;
+        })();
+        // Fail early if no model available
+        if (!modelParam) {
+            throw new Error('No AI provider connected. Configure a provider in OpenCode with `/connect` command.');
+        }
+        // Build worktree info for system message (worktreeInfo was fetched at the start)
+        const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+            ? {
+                worktreeDirectory: worktreeInfo.worktree_directory,
+                branch: worktreeInfo.worktree_name,
+                mainRepoDirectory: worktreeInfo.project_directory,
+            }
+            : undefined;
+        hasSentParts = false;
+        const response = command
+            ? await getClient().session.command({
+                path: { id: session.id },
+                query: { directory: sdkDirectory },
+                body: {
+                    command: command.name,
+                    arguments: command.arguments,
+                    agent: agentPreference,
+                },
+                signal: abortController.signal,
+            })
+            : await getClient().session.prompt({
+                path: { id: session.id },
+                query: { directory: sdkDirectory },
+                body: {
+                    parts,
+                    system: getOpencodeSystemMessage({
+                        sessionId: session.id,
+                        channelId,
+                        worktree,
+                    }),
+                    model: modelParam,
+                    agent: agentPreference,
+                },
+                signal: abortController.signal,
+            });
+        if (response.error) {
+            const errorMessage = (() => {
+                const err = response.error;
+                if (err && typeof err === 'object') {
+                    if ('data' in err &&
+                        err.data &&
+                        typeof err.data === 'object' &&
+                        'message' in err.data) {
+                        return String(err.data.message);
+                    }
+                    if ('errors' in err &&
+                        Array.isArray(err.errors) &&
+                        err.errors.length > 0) {
+                        return JSON.stringify(err.errors);
+                    }
+                }
+                return JSON.stringify(err);
+            })();
+            throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
+        }
+        promptResolved = true;
+        sessionLogger.log(`Successfully sent prompt, got response`);
+        if (originalMessage) {
+            const reactionResult = await errore.tryAsync(async () => {
+                await originalMessage.reactions.removeAll();
+                await originalMessage.react('✅');
+            });
+            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);
+            }),
+        ]);
+    }
+    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);
+    sessionLogger.log(`[ABORT] reason=error sessionId=${session.id} threadId=${thread.id} - prompt failed with error: ${promptError.message}`);
+    abortController.abort(new Error('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}`);
+}
+async function sendHubNotification({ appId, thread, directory, sessionDuration, contextInfo, modelInfo, }) {
+    const result = await errore.tryAsync(async () => {
+        const settings = getBotSettings(appId);
+        if (!settings.hub_channel_id) {
+            return;
+        }
+        const hubChannel = await thread.client.channels.fetch(settings.hub_channel_id);
+        if (!hubChannel?.isTextBased() || !('send' in hubChannel)) {
+            return;
+        }
+        const projectName = directory.split('/').pop() || directory;
+        const threadUrl = `https://discord.com/channels/${thread.guildId}/${thread.id}`;
+        await hubChannel.send({
+            content: `✅ **${projectName}** completed\n⏱ ${sessionDuration}${contextInfo}${modelInfo}\n🧵 [${thread.name}](${threadUrl})`,
+            flags: NOTIFY_MESSAGE_FLAGS,
+        });
+    });
+    if (result instanceof Error) {
+        sessionLogger.error('Failed to send hub notification:', result);
+    }
+}