@brianli/kimaki 0.4.72-brianli.1

package/dist/session-handler.js

@@ -0,0 +1,1874 @@
+// 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 { ChannelType } from 'discord.js';
+import prettyMilliseconds from 'pretty-ms';
+import fs from 'node:fs';
+import path from 'node:path';
+import { xdgState } from 'xdg-basedir';
+import { getSessionAgent, getSessionModel, getVariantCascade, getChannelAgent, setSessionAgent, getThreadWorktree, getChannelVerbosity, getThreadSession, setThreadSession, getPartMessageIds, setPartMessage, getChannelDirectory, setSessionStartSource, } from './database.js';
+import { ensureSessionPreferencesSnapshot, getCurrentModelInfo, } from './commands/model.js';
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClient, } from './opencode.js';
+import { sendThreadMessage, resolveWorkingDirectory, 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 { SessionAbortError } from './errors.js';
+import { notifyError } from './sentry.js';
+import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
+import { showPermissionButtons, cleanupPermissionContext, addPermissionRequestToContext, arePatternsCoveredBy, } from './commands/permissions.js';
+import { cancelPendingFileUpload } from './commands/file-upload.js';
+import { cancelPendingActionButtons, showActionButtons, waitForQueuedActionButtonsRequest, } from './commands/action-buttons.js';
+import { getThinkingValuesForModel, matchThinkingValue, } from './thinking-utils.js';
+import { execAsync } from './worktree-utils.js';
+import * as errore from 'errore';
+import * as sessionRunState from './session-handler/state.js';
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const discordLogger = createLogger(LogPrefix.DISCORD);
+export const abortControllers = new Map();
+/** Format opencode session error with status, provider, and response body for debugging. */
+function formatSessionError(error) {
+    const name = error?.name || 'Error';
+    // Prefer data.message (SDK shape), fall back to error.message (plain Error)
+    const message = error?.data?.message ||
+        error?.message ||
+        'Unknown error';
+    const details = [];
+    if (error?.data?.statusCode !== undefined) {
+        details.push(`status=${error.data.statusCode}`);
+    }
+    if (error?.data?.providerID) {
+        details.push(`provider=${error.data.providerID}`);
+    }
+    if (typeof error?.data?.isRetryable === 'boolean') {
+        details.push(error.data.isRetryable ? 'retryable' : 'non-retryable');
+    }
+    const responseBody = typeof error?.data?.responseBody === 'string'
+        ? error.data.responseBody.trim()
+        : '';
+    if (responseBody) {
+        details.push(`body=${responseBody.slice(0, 180)}`);
+    }
+    const suffix = details.length > 0 ? ` (${details.join(', ')})` : '';
+    return `${name}: ${message}${suffix}`;
+}
+export function signalThreadInterrupt({ threadId, serverDirectory, sdkDirectory, }) {
+    void (async () => {
+        const sessionId = await getThreadSession(threadId);
+        if (!sessionId) {
+            return;
+        }
+        const controller = abortControllers.get(sessionId);
+        if (!controller || controller.signal.aborted) {
+            return;
+        }
+        sessionLogger.log(`[ABORT] reason=queued-message sessionId=${sessionId} threadId=${threadId} - new message queued, aborting running session immediately`);
+        controller.abort(new SessionAbortError({ reason: 'new-request' }));
+        if (!serverDirectory || !sdkDirectory) {
+            return;
+        }
+        const client = getOpencodeClient(serverDirectory);
+        if (!client) {
+            sessionLogger.log(`[ABORT-API] reason=queued-message sessionId=${sessionId} - no OpenCode client found for directory ${serverDirectory}`);
+            return;
+        }
+        const abortResult = await errore.tryAsync(() => {
+            return client.session.abort({
+                sessionID: sessionId,
+                directory: sdkDirectory,
+            });
+        });
+        if (abortResult instanceof Error) {
+            sessionLogger.log(`[ABORT-API] reason=queued-message sessionId=${sessionId} - API abort failed (may already be done):`, abortResult);
+        }
+    })();
+}
+// 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',
+    'question',
+    'kimaki_action_buttons',
+    '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();
+async function removeBotErrorReaction({ message, }) {
+    const botUserId = message.client.user?.id;
+    if (!botUserId) {
+        return;
+    }
+    const errorReaction = message.reactions.cache.find((reaction) => {
+        return reaction.emoji.name === '❌';
+    });
+    if (!errorReaction) {
+        return;
+    }
+    await errorReaction.users.remove(botUserId);
+}
+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);
+}
+/**
+ * Queue a message if there's an active in-progress request, otherwise send immediately.
+ * Abstracts the "check active request → send or queue" pattern used by /queue command
+ * and voice transcription queue detection.
+ *
+ * Checks active request BEFORE resolving directory so that queueing works even if
+ * directory resolution would fail — the queued message only needs a directory later
+ * when it's actually sent (the drain logic in handleOpencodeSession already has it).
+ *
+ * If there is no existing session or no project directory (on immediate-send path),
+ * returns an error-like result so the caller can handle it.
+ */
+export async function queueOrSendMessage({ thread, prompt, userId, username, appId, images, forceQueue, }) {
+    const sessionId = await getThreadSession(thread.id);
+    if (!sessionId) {
+        return { action: 'no-session' };
+    }
+    // Check active request FIRST — queueing doesn't need directory resolution
+    const existingController = abortControllers.get(sessionId);
+    const hasActiveRequest = Boolean(existingController && !existingController.signal.aborted);
+    if (existingController && existingController.signal.aborted) {
+        abortControllers.delete(sessionId);
+    }
+    if (hasActiveRequest || forceQueue) {
+        // Active request — add to queue (no directory needed, drain logic has it)
+        const position = addToQueue({
+            threadId: thread.id,
+            message: {
+                prompt,
+                userId,
+                username,
+                queuedAt: Date.now(),
+                images,
+                appId,
+            },
+        });
+        sessionLogger.log(`[QUEUE] User ${username} queued message in thread ${thread.id} (position: ${position})`);
+        return { action: 'queued', position };
+    }
+    // No active request — send immediately (need directory for this path)
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    if (!resolved) {
+        return { action: 'no-directory' };
+    }
+    sessionLogger.log(`[QUEUE] No active request, sending immediately in thread ${thread.id}`);
+    handleOpencodeSession({
+        prompt,
+        thread,
+        projectDirectory: resolved.projectDirectory,
+        channelId: thread.parentId || thread.id,
+        images,
+        username,
+        userId,
+        appId,
+    }).catch(async (e) => {
+        sessionLogger.error(`[QUEUE] Failed to send message:`, e);
+        void notifyError(e, 'Queue: failed to send message');
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        await sendThreadMessage(thread, `✗ Failed: ${errorMsg.slice(0, 200)}`);
+    });
+    return { action: 'sent' };
+}
+/**
+ * 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;
+}
+async function resolveValidatedAgentPreference({ agent, sessionId, channelId, getClient, }) {
+    const agentPreference = await (async () => {
+        if (agent) {
+            return agent;
+        }
+        const sessionAgent = await getSessionAgent(sessionId);
+        if (sessionAgent) {
+            return sessionAgent;
+        }
+        const sessionModel = await getSessionModel(sessionId);
+        if (sessionModel) {
+            return undefined;
+        }
+        if (!channelId) {
+            return undefined;
+        }
+        return getChannelAgent(channelId);
+    })();
+    if (getClient instanceof Error) {
+        return { agentPreference: agentPreference || undefined, agents: [] };
+    }
+    const agentsResponse = await errore.tryAsync(() => {
+        return getClient().app.agents({});
+    });
+    if (agentsResponse instanceof Error) {
+        if (agentPreference) {
+            throw new Error(`Failed to validate agent "${agentPreference}"`, {
+                cause: agentsResponse,
+            });
+        }
+        return { agentPreference: undefined, agents: [] };
+    }
+    const availableAgents = agentsResponse.data || [];
+    // Non-hidden primary/all agents for system message context
+    const agents = availableAgents
+        .filter((a) => {
+        return ((a.mode === 'primary' || a.mode === 'all') &&
+            !a.hidden);
+    })
+        .map((a) => {
+        return { name: a.name, description: a.description };
+    });
+    if (!agentPreference) {
+        return { agentPreference: undefined, agents };
+    }
+    const hasAgent = availableAgents.some((availableAgent) => {
+        return availableAgent.name === agentPreference;
+    });
+    if (hasAgent) {
+        return { agentPreference, agents };
+    }
+    const availableAgentNames = availableAgents
+        .map((availableAgent) => {
+        return availableAgent.name;
+    })
+        .slice(0, 20);
+    const availableAgentsMessage = availableAgentNames.length > 0
+        ? `Available agents: ${availableAgentNames.join(', ')}`
+        : 'No agents are available in this project.';
+    throw new Error(`Agent "${agentPreference}" not found. ${availableAgentsMessage} Use /agent to choose a valid one.`);
+}
+/**
+ * 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
+ * Returns the model and its source.
+ */
+export async function getDefaultModel({ getClient, }) {
+    if (getClient instanceof Error) {
+        return undefined;
+    }
+    // Fetch connected providers to validate any model we return
+    const providersResponse = await errore.tryAsync(() => {
+        return getClient().provider.list({});
+    });
+    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({});
+    });
+    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, source: 'opencode-config' };
+        }
+        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, source: 'opencode-recent' };
+        }
+    }
+    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,
+        source: 'opencode-provider-default',
+    };
+}
+/**
+ * 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, appId, channelId, }) {
+    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 SessionAbortError({ reason: 'model-change' }));
+    // Also call the API abort endpoint
+    const getClient = await initializeOpencodeForDirectory(projectDirectory, {
+        channelId,
+    });
+    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({ sessionID: 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({
+        sessionID: 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 (skip synthetic parts like branch context)
+    const textPart = lastUserMessage.parts.find((p) => p.type === 'text' && !p.synthetic);
+    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,
+                appId,
+                channelId,
+            });
+        })
+            .then(async (result) => {
+            if (!(result instanceof Error)) {
+                return;
+            }
+            sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, result);
+            void notifyError(result, 'Abort+retry session failed');
+            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, model, username, userId, appId, sessionStartSource, }) {
+    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}`);
+    // Fire DB lookups in parallel - they're independent and we need both before proceeding.
+    // initializeOpencodeForDirectory is NOT included here because it needs worktree info
+    // to set originalRepoDirectory permissions on the spawned server (reuse check means
+    // a second call with different options won't fix a server already spawned without them).
+    const [worktreeInfo, existingSessionId] = await Promise.all([
+        getThreadWorktree(thread.id),
+        getThreadSession(thread.id),
+    ]);
+    const worktreeDirectory = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+        ? worktreeInfo.worktree_directory
+        : undefined;
+    const sdkDirectory = worktreeDirectory || directory;
+    if (worktreeDirectory) {
+        sessionLogger.log(`Using worktree directory for SDK calls: ${worktreeDirectory}`);
+    }
+    const originalRepoDirectory = worktreeDirectory
+        ? worktreeInfo?.project_directory
+        : undefined;
+    const getClient = await initializeOpencodeForDirectory(directory, {
+        originalRepoDirectory,
+        channelId,
+    });
+    if (getClient instanceof Error) {
+        await sendThreadMessage(thread, `✗ ${getClient.message}`);
+        return;
+    }
+    const serverEntry = getOpencodeServers().get(directory);
+    const port = serverEntry?.port;
+    let sessionId = existingSessionId;
+    let session;
+    let createdNewSession = false;
+    if (sessionId) {
+        sessionLogger.log(`Attempting to reuse existing session ${sessionId}`);
+        const sessionResponse = await errore.tryAsync(() => {
+            return getClient().session.get({
+                sessionID: sessionId,
+                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}`);
+        }
+    }
+    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({
+            title: sessionTitle,
+            directory: sdkDirectory,
+        });
+        session = sessionResponse.data;
+        createdNewSession = true;
+        sessionLogger.log(`Created new session ${session?.id}`);
+    }
+    if (!session) {
+        throw new Error('Failed to create or get session');
+    }
+    await setThreadSession(thread.id, session.id);
+    sessionLogger.log(`Stored session ${session.id} for thread ${thread.id}`);
+    const channelInfo = channelId
+        ? await getChannelDirectory(channelId)
+        : undefined;
+    const resolvedAppId = channelInfo?.appId ?? appId;
+    if (createdNewSession && sessionStartSource) {
+        const saveStartSourceResult = await errore.tryAsync(() => {
+            return setSessionStartSource({
+                sessionId: session.id,
+                scheduleKind: sessionStartSource.scheduleKind,
+                scheduledTaskId: sessionStartSource.scheduledTaskId,
+            });
+        });
+        if (saveStartSourceResult instanceof Error) {
+            sessionLogger.warn(`[SESSION] Failed to store start source for session ${session.id}: ${saveStartSourceResult.message}`);
+        }
+    }
+    // Store agent preference if provided
+    if (agent) {
+        await setSessionAgent(session.id, agent);
+        sessionLogger.log(`Set agent preference for session ${session.id}: ${agent}`);
+    }
+    await ensureSessionPreferencesSnapshot({
+        sessionId: session.id,
+        channelId,
+        appId: resolvedAppId,
+        getClient,
+        agentOverride: agent,
+        modelOverride: model,
+        force: createdNewSession,
+    });
+    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 SessionAbortError({ reason: 'new-request' }));
+        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({
+                sessionID: session.id,
+                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 permClient = getOpencodeClient(directory);
+        for (const [permId, pendingPerm] of threadPermissions) {
+            sessionLogger.log(`[PERMISSION] Auto-rejecting permission ${permId} due to new message`);
+            // Remove the permission buttons from the Discord message
+            const removeButtonsResult = await errore.tryAsync(async () => {
+                const msg = await thread.messages.fetch(pendingPerm.messageId);
+                await msg.edit({ components: [] });
+            });
+            if (removeButtonsResult instanceof Error) {
+                sessionLogger.log(`[PERMISSION] Failed to remove buttons for ${permId}:`, removeButtonsResult);
+            }
+            if (!permClient) {
+                sessionLogger.log(`[PERMISSION] OpenCode client unavailable for permission ${permId}`);
+                cleanupPermissionContext(pendingPerm.contextHash);
+                continue;
+            }
+            const rejectResult = await errore.tryAsync(() => {
+                return permClient.permission.reply({
+                    requestID: permId,
+                    directory: pendingPerm.permissionDirectory,
+                    reply: 'reject',
+                });
+            });
+            if (rejectResult instanceof Error) {
+                sessionLogger.log(`[PERMISSION] Failed to auto-reject permission ${permId}:`, rejectResult);
+            }
+            cleanupPermissionContext(pendingPerm.contextHash);
+        }
+        pendingPermissions.delete(thread.id);
+    }
+    // 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`);
+    }
+    // Cancel any pending file upload (resolves with empty array so plugin tool unblocks)
+    const fileUploadCancelled = await cancelPendingFileUpload(thread.id);
+    if (fileUploadCancelled) {
+        sessionLogger.log(`[FILE-UPLOAD] Cancelled pending file upload due to new message`);
+    }
+    // Dismiss any pending action buttons (user sent a new message instead of clicking)
+    const actionButtonsDismissed = cancelPendingActionButtons(thread.id);
+    if (actionButtonsDismissed) {
+        sessionLogger.log(`[ACTION] Dismissed pending action buttons due to new message`);
+    }
+    // Snapshot model+agent early so user changes (e.g. /agent) during the async gap
+    // (debounce, previous handler wait, event subscribe) don't affect this request.
+    const earlyAgentResult = await errore.tryAsync(() => {
+        return resolveValidatedAgentPreference({
+            agent,
+            sessionId: session.id,
+            channelId,
+            getClient,
+        });
+    });
+    if (earlyAgentResult instanceof Error) {
+        await sendThreadMessage(thread, `Failed to resolve agent: ${earlyAgentResult.message}`);
+        return;
+    }
+    const earlyAgentPreference = earlyAgentResult.agentPreference;
+    const earlyAvailableAgents = earlyAgentResult.agents;
+    if (earlyAgentPreference) {
+        sessionLogger.log(`[AGENT] Resolved agent preference early: ${earlyAgentPreference}`);
+    }
+    // Model resolution and variant cascade are independent - run in parallel.
+    // Variant cascade only needs resolvedAppId (available now). Variant validation
+    // against the model happens after both complete.
+    const [earlyModelResult, preferredVariant] = await Promise.all([
+        errore.tryAsync(async () => {
+            if (model) {
+                const [providerID, ...modelParts] = model.split('/');
+                const modelID = modelParts.join('/');
+                if (providerID && modelID) {
+                    sessionLogger.log(`[MODEL] Using explicit model (early): ${model}`);
+                    return { providerID, modelID };
+                }
+            }
+            const modelInfo = await getCurrentModelInfo({
+                sessionId: session.id,
+                channelId,
+                appId: resolvedAppId,
+                agentPreference: earlyAgentPreference,
+                getClient,
+            });
+            if (modelInfo.type === 'none') {
+                sessionLogger.log(`[MODEL] No model available (early resolution)`);
+                return undefined;
+            }
+            sessionLogger.log(`[MODEL] Resolved ${modelInfo.type} early: ${modelInfo.model}`);
+            return { providerID: modelInfo.providerID, modelID: modelInfo.modelID };
+        }),
+        getVariantCascade({
+            sessionId: session.id,
+            channelId,
+            appId: resolvedAppId,
+        }),
+    ]);
+    if (earlyModelResult instanceof Error) {
+        await sendThreadMessage(thread, `Failed to resolve model: ${earlyModelResult.message}`);
+        return;
+    }
+    const earlyModelParam = earlyModelResult;
+    if (!earlyModelParam) {
+        await sendThreadMessage(thread, 'No AI provider connected. Configure a provider in OpenCode with `/connect` command.');
+        return;
+    }
+    // Validate the preferred variant against the current model's available variants.
+    // preferredVariant was already fetched in parallel above.
+    const earlyThinkingValue = await (async () => {
+        if (!preferredVariant) {
+            return undefined;
+        }
+        const providersResponse = await errore.tryAsync(() => {
+            return getClient().provider.list({ directory: sdkDirectory });
+        });
+        if (providersResponse instanceof Error || !providersResponse.data) {
+            return undefined;
+        }
+        const availableValues = getThinkingValuesForModel({
+            providers: providersResponse.data.all,
+            providerId: earlyModelParam.providerID,
+            modelId: earlyModelParam.modelID,
+        });
+        if (availableValues.length === 0) {
+            sessionLogger.log(`[THINK] Model ${earlyModelParam.providerID}/${earlyModelParam.modelID} has no variants, ignoring preference`);
+            return undefined;
+        }
+        const matched = matchThinkingValue({
+            requestedValue: preferredVariant,
+            availableValues,
+        });
+        if (!matched) {
+            sessionLogger.log(`[THINK] Preference "${preferredVariant}" invalid for current model, ignoring`);
+            return undefined;
+        }
+        sessionLogger.log(`[THINK] Using variant: ${matched}`);
+        return matched;
+    })();
+    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`);
+        const previousHandlerResult = await errore.tryAsync(() => {
+            return previousHandler;
+        });
+        if (previousHandlerResult instanceof Error) {
+            sessionLogger.warn(`[EVENT] Previous handler exited with error while waiting: ${previousHandlerResult.message}`);
+        }
+    }
+    const eventClient = getOpencodeClient(directory);
+    if (!eventClient) {
+        throw new Error(`OpenCode client not found for directory: ${directory}`);
+    }
+    const eventsResult = await eventClient.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 existingPartIds = await getPartMessageIds(thread.id);
+    const sentPartIds = new Set(existingPartIds);
+    const partBuffer = new Map();
+    let usedModel = earlyModelParam.modelID;
+    let usedProviderID = earlyModelParam.providerID;
+    let usedAgent;
+    let tokensUsedInSession = 0;
+    let lastDisplayedContextPercentage = 0;
+    let lastRateLimitDisplayTime = 0;
+    let modelContextLimit;
+    let modelContextLimitKey;
+    let assistantMessageId;
+    let handlerPromise = null;
+    let typingInterval = null;
+    let typingRestartTimeout = null;
+    let handlerClosed = false;
+    let hasSentParts = false;
+    const mainRunStore = sessionRunState.createMainRunStore();
+    const finishMainSessionFromIdle = () => {
+        if (abortController.signal.aborted) {
+            return;
+        }
+        sessionRunState.markFinished({ store: mainRunStore });
+        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 SessionAbortError({ reason: 'finished' }));
+    };
+    function clearTypingInterval() {
+        if (!typingInterval) {
+            return;
+        }
+        clearInterval(typingInterval);
+        typingInterval = null;
+    }
+    function clearTypingRestartTimeout() {
+        if (!typingRestartTimeout) {
+            return;
+        }
+        clearTimeout(typingRestartTimeout);
+        typingRestartTimeout = null;
+    }
+    function stopTyping() {
+        clearTypingInterval();
+        clearTypingRestartTimeout();
+    }
+    function startTyping() {
+        if (abortController.signal.aborted || handlerClosed) {
+            discordLogger.log(`Not starting typing, handler already closing`);
+            return;
+        }
+        clearTypingRestartTimeout();
+        clearTypingInterval();
+        void errore
+            .tryAsync(() => thread.sendTyping())
+            .then((result) => {
+            if (result instanceof Error) {
+                discordLogger.log(`Failed to send initial typing: ${result}`);
+            }
+        });
+        typingInterval = setInterval(() => {
+            if (abortController.signal.aborted || handlerClosed) {
+                clearTypingInterval();
+                return;
+            }
+            void errore
+                .tryAsync(() => thread.sendTyping())
+                .then((result) => {
+                if (result instanceof Error) {
+                    discordLogger.log(`Failed to send periodic typing: ${result}`);
+                }
+            });
+        }, 8000);
+    }
+    function scheduleTypingRestart() {
+        clearTypingRestartTimeout();
+        if (abortController.signal.aborted || handlerClosed) {
+            return;
+        }
+        typingRestartTimeout = setTimeout(() => {
+            typingRestartTimeout = null;
+            if (abortController.signal.aborted || handlerClosed) {
+                return;
+            }
+            const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => {
+                return ctx.thread.id === thread.id;
+            });
+            const hasPendingPermission = (pendingPermissions.get(thread.id)?.size ?? 0) > 0;
+            if (hasPendingQuestion || hasPendingPermission) {
+                return;
+            }
+            startTyping();
+        }, 300);
+    }
+    if (!abortController.signal.aborted) {
+        abortController.signal.addEventListener('abort', () => {
+            stopTyping();
+        }, { once: true });
+    }
+    // Read verbosity dynamically so mid-session /verbosity changes take effect immediately
+    const verbosityChannelId = channelId || thread.parentId || thread.id;
+    const getVerbosity = async () => {
+        return getChannelVerbosity(verbosityChannelId);
+    };
+    const sendPartMessage = async (part) => {
+        const verbosity = await 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) + '\n\n';
+        if (!content.trim() || content.length === 0) {
+            // discordLogger.log(`SKIP: Part ${part.id} has no content`)
+            return;
+        }
+        if (sentPartIds.has(part.id)) {
+            return;
+        }
+        // Mark as sent BEFORE the async send to prevent concurrent flushes
+        // (from message.updated, step-finish, finally block) from sending the
+        // same part while this await is in-flight. If the send fails we remove
+        // the id so a retry can pick it up.
+        sentPartIds.add(part.id);
+        const sendResult = await errore.tryAsync(() => {
+            return sendThreadMessage(thread, content);
+        });
+        if (sendResult instanceof Error) {
+            sentPartIds.delete(part.id);
+            discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult);
+            return;
+        }
+        hasSentParts = true;
+        await setPartMessage(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 showInteractiveUi = async ({ skipPartId, flushMessageId, show, }) => {
+            stopTyping();
+            const targetMessageId = flushMessageId || assistantMessageId;
+            if (targetMessageId) {
+                await flushBufferedParts({
+                    messageID: targetMessageId,
+                    force: true,
+                    skipPartId,
+                });
+            }
+            await show();
+        };
+        const ensureModelContextLimit = async () => {
+            if (!usedProviderID || !usedModel) {
+                return;
+            }
+            const key = `${usedProviderID}/${usedModel}`;
+            if (modelContextLimit && modelContextLimitKey === key) {
+                return;
+            }
+            const providersResponse = await errore.tryAsync(() => {
+                return getClient().provider.list({
+                    directory: sdkDirectory,
+                });
+            });
+            if (providersResponse instanceof Error) {
+                sessionLogger.error('Failed to fetch provider info for context limit:', providersResponse);
+                return;
+            }
+            const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+            const model = provider?.models?.[usedModel];
+            if (!model?.limit?.context) {
+                return;
+            }
+            modelContextLimit = model.limit.context;
+            modelContextLimitKey = key;
+        };
+        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;
+            }
+            sessionRunState.markCurrentPromptEvidence({
+                store: mainRunStore,
+                messageId: msg.id,
+            });
+            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;
+            }
+            await ensureModelContextLimit();
+            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) {
+                    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 ((await getVerbosity()) !== 'text-only') {
+                            const taskDisplay = `┣ task **${description}**${agent ? ` _${agent}_` : ''}`;
+                            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') {
+                if (part.tool.endsWith('kimaki_action_buttons')) {
+                    await showInteractiveUi({
+                        skipPartId: part.id,
+                        flushMessageId: assistantMessageId || part.messageID,
+                        show: async () => {
+                            const request = await waitForQueuedActionButtonsRequest({
+                                sessionId: session.id,
+                                timeoutMs: 1500,
+                            });
+                            if (!request) {
+                                sessionLogger.warn(`[ACTION] No queued action-buttons request found for session ${session.id}`);
+                                return;
+                            }
+                            if (request.threadId !== thread.id) {
+                                sessionLogger.warn(`[ACTION] Ignoring queued action-buttons for different thread (expected: ${thread.id}, got: ${request.threadId})`);
+                                return;
+                            }
+                            const showButtonsResult = await errore.tryAsync(() => {
+                                return showActionButtons({
+                                    thread,
+                                    sessionId: request.sessionId,
+                                    directory: request.directory,
+                                    buttons: request.buttons,
+                                });
+                            });
+                            if (!(showButtonsResult instanceof Error)) {
+                                return;
+                            }
+                            sessionLogger.error('[ACTION] Failed to show action buttons:', showButtonsResult);
+                            await sendThreadMessage(thread, `Failed to show action buttons: ${showButtonsResult.message}`);
+                        },
+                    });
+                    return;
+                }
+                const showLargeOutput = await (async () => {
+                    const verbosity = await 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) {
+                        await ensureModelContextLimit();
+                        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,
+                });
+                scheduleTypingRestart();
+            }
+        };
+        const handleSubtaskPart = async (part, subtaskInfo) => {
+            const verbosity = await 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);
+            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);
+            await setPartMessage(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 (part.sessionID === session.id) {
+                sessionRunState.markCurrentPromptEvidence({
+                    store: mainRunStore,
+                    messageId: part.messageID,
+                });
+            }
+            if (isSubtaskEvent && subtaskInfo) {
+                await handleSubtaskPart(part, subtaskInfo);
+                return;
+            }
+            await handleMainPart(part);
+        };
+        const handleSessionError = async ({ sessionID, error, }) => {
+            if (!sessionID || sessionID !== session.id) {
+                sessionLogger.log(`Ignoring error for different session (expected: ${session.id}, got: ${sessionID})`);
+                return;
+            }
+            // Skip abort errors from the server — these are expected when operations
+            // are cancelled. Checks server error name and the local abort signal.
+            if (error?.name === 'MessageAbortedError' ||
+                abortController.signal.aborted) {
+                sessionLogger.log(`Operation aborted (expected)`);
+                return;
+            }
+            const errorMessage = formatSessionError(error);
+            sessionLogger.error(`Sending error to thread: ${errorMessage}`);
+            const errorPayload = (() => {
+                try {
+                    return JSON.stringify(error);
+                }
+                catch {
+                    return '[unserializable error payload]';
+                }
+            })();
+            sessionLogger.error(`Session error payload:`, errorPayload);
+            await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`);
+            if (!originalMessage) {
+                return;
+            }
+            const reactionResult = await errore.tryAsync(async () => {
+                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) => {
+                    if (pending.dedupeKey === dedupeKey) {
+                        return true;
+                    }
+                    if (pending.directory !== directory) {
+                        return false;
+                    }
+                    if (pending.permission.permission !== permission.permission) {
+                        return false;
+                    }
+                    return arePatternsCoveredBy({
+                        patterns: permission.patterns,
+                        coveringPatterns: pending.permission.patterns,
+                    });
+                })
+                : undefined;
+            if (existingPending) {
+                sessionLogger.log(`[PERMISSION] Deduped permission ${permission.id} (matches pending ${existingPending.permission.id})`);
+                stopTyping();
+                if (!pendingPermissions.has(thread.id)) {
+                    pendingPermissions.set(thread.id, new Map());
+                }
+                pendingPermissions.get(thread.id).set(permission.id, {
+                    permission,
+                    messageId: existingPending.messageId,
+                    directory,
+                    permissionDirectory: existingPending.permissionDirectory,
+                    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}` : ''}`);
+            stopTyping();
+            const { messageId, contextHash } = await showPermissionButtons({
+                thread,
+                permission,
+                directory,
+                permissionDirectory: sdkDirectory,
+                subtaskLabel,
+            });
+            if (!pendingPermissions.has(thread.id)) {
+                pendingPermissions.set(thread.id, new Map());
+            }
+            pendingPermissions.get(thread.id).set(permission.id, {
+                permission,
+                messageId,
+                directory,
+                permissionDirectory: sdkDirectory,
+                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}`);
+            await showInteractiveUi({
+                flushMessageId: assistantMessageId,
+                show: async () => {
+                    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}`);
+            const displayText = nextMessage.command
+                ? `/${nextMessage.command.name}`
+                : `${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`;
+            await sendThreadMessage(thread, `» **${nextMessage.username}:** ${displayText}`);
+            setImmediate(() => {
+                void errore
+                    .tryAsync(async () => {
+                    return handleOpencodeSession({
+                        prompt: nextMessage.prompt,
+                        thread,
+                        projectDirectory: directory,
+                        images: nextMessage.images,
+                        channelId,
+                        username: nextMessage.username,
+                        appId: nextMessage.appId,
+                        command: nextMessage.command,
+                    });
+                })
+                    .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 handleTuiToast = async (properties) => {
+            if (properties.variant === 'warning') {
+                return;
+            }
+            const message = properties.message.trim();
+            if (!message) {
+                return;
+            }
+            const titlePrefix = properties.title ? `${properties.title.trim()}: ` : '';
+            const chunk = `⬦ ${properties.variant}: ${titlePrefix}${message}`;
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        };
+        const handleSessionIdle = (idleSessionId) => {
+            if (idleSessionId === session.id) {
+                const idleDecision = sessionRunState.handleMainSessionIdle({
+                    store: mainRunStore,
+                });
+                if (idleDecision === 'deferred') {
+                    sessionLogger.log(`[SESSION IDLE] Deferring idle event for ${session.id} until prompt resolves`);
+                    return;
+                }
+                if (idleDecision === 'ignore-no-evidence') {
+                    sessionLogger.log(`[SESSION IDLE] Ignoring idle event for ${session.id} (no current-prompt events yet)`);
+                    return;
+                }
+                finishMainSessionFromIdle();
+                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':
+                        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;
+                    case 'session.status':
+                        await handleSessionStatus(event.properties);
+                        break;
+                    case 'tui.toast.show':
+                        await handleTuiToast(event.properties);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        catch (e) {
+            if (isAbortError(e)) {
+                sessionLogger.log('AbortController aborted event handling (normal exit)');
+                return;
+            }
+            sessionLogger.error(`Unexpected error in event handling code`, e);
+            throw e;
+        }
+        finally {
+            handlerClosed = true;
+            const activeController = abortControllers.get(session.id);
+            if (activeController === abortController) {
+                abortControllers.delete(session.id);
+            }
+            const abortReason = abortController.signal.reason instanceof SessionAbortError
+                ? abortController.signal.reason.reason
+                : undefined;
+            if (abortController.signal.aborted &&
+                mainRunStore.getState().phase !== 'finished') {
+                sessionRunState.markAborted({ store: mainRunStore });
+            }
+            const shouldFlushFinalParts = !abortController.signal.aborted || abortReason === 'finished';
+            if (shouldFlushFinalParts) {
+                const finalMessageId = assistantMessageId;
+                if (finalMessageId) {
+                    const parts = getBufferedParts(finalMessageId);
+                    for (const part of parts) {
+                        if (!sentPartIds.has(part.id)) {
+                            await sendPartMessage(part);
+                        }
+                    }
+                }
+            }
+            stopTyping();
+            if (!abortController.signal.aborted || abortReason === 'finished') {
+                const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime, {
+                    secondsDecimalDigits: 0,
+                });
+                const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
+                const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build'
+                    ? ` ⋅ **${usedAgent}**`
+                    : '';
+                let contextInfo = '';
+                const folderName = path.basename(sdkDirectory);
+                // Run git branch, token fetch, and provider list in parallel to
+                // minimize footer latency (matters for archive-thread 5s delay race)
+                const [branchResult, contextResult] = await Promise.all([
+                    errore.tryAsync(() => {
+                        return execAsync('git symbolic-ref --short HEAD', {
+                            cwd: sdkDirectory,
+                        });
+                    }),
+                    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
+                        const [messagesResult, providersResult] = await Promise.all([
+                            tokensUsedInSession === 0
+                                ? errore.tryAsync(() => {
+                                    return getClient().session.messages({
+                                        sessionID: session.id,
+                                        directory: sdkDirectory,
+                                    });
+                                })
+                                : null,
+                            errore.tryAsync(() => {
+                                return getClient().provider.list({
+                                    directory: sdkDirectory,
+                                });
+                            }),
+                        ]);
+                        if (messagesResult && !(messagesResult instanceof Error)) {
+                            const messages = messagesResult.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;
+                            }
+                        }
+                        if (providersResult && !(providersResult instanceof Error)) {
+                            const provider = providersResult.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}%`;
+                            }
+                        }
+                    }),
+                ]);
+                const branchName = branchResult instanceof Error ? '' : branchResult.stdout.trim();
+                if (contextResult instanceof Error) {
+                    sessionLogger.error('Failed to fetch provider info for context percentage:', contextResult);
+                }
+                const projectInfo = branchName
+                    ? `${folderName} ⋅ ${branchName} ⋅ `
+                    : `${folderName} ⋅ `;
+                await sendThreadMessage(thread, `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*`, { flags: NOTIFY_MESSAGE_FLAGS });
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
+                // 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
+                    const displayText = nextMessage.command
+                        ? `/${nextMessage.command.name}`
+                        : `${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`;
+                    await sendThreadMessage(thread, `» **${nextMessage.username}:** ${displayText}`);
+                    // Send the queued message as a new prompt (recursive call)
+                    // Use setImmediate to avoid blocking and allow this finally to complete
+                    setImmediate(() => {
+                        handleOpencodeSession({
+                            prompt: nextMessage.prompt,
+                            thread,
+                            projectDirectory,
+                            images: nextMessage.images,
+                            channelId,
+                            username: nextMessage.username,
+                            appId: nextMessage.appId,
+                            command: nextMessage.command,
+                        }).catch(async (e) => {
+                            sessionLogger.error(`[QUEUE] Failed to process queued message:`, e);
+                            void notifyError(e, 'Queued message processing failed');
+                            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;
+        }
+        startTyping();
+        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}`;
+        })();
+        // Synthetic context for the model (hidden in TUI)
+        let syntheticContext = '';
+        if (username) {
+            syntheticContext += `<discord-user name="${username}" />`;
+        }
+        const parts = [
+            { type: 'text', text: promptWithImagePaths },
+            { type: 'text', text: syntheticContext, synthetic: true },
+            ...images,
+        ];
+        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+        // Use model+agent snapshotted at message arrival (before debounce/subscribe gap)
+        const agentPreference = earlyAgentPreference;
+        const modelParam = earlyModelParam;
+        // 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;
+        const channelTopic = await (async () => {
+            if (thread.parent?.type === ChannelType.GuildText) {
+                return thread.parent.topic?.trim() || undefined;
+            }
+            if (!channelId) {
+                return undefined;
+            }
+            const fetched = await errore.tryAsync(() => {
+                return thread.guild.channels.fetch(channelId);
+            });
+            if (fetched instanceof Error || !fetched) {
+                return undefined;
+            }
+            if (fetched.type !== ChannelType.GuildText) {
+                return undefined;
+            }
+            return fetched.topic?.trim() || undefined;
+        })();
+        hasSentParts = false;
+        sessionRunState.beginPromptCycle({ store: mainRunStore });
+        const messagesBeforePromptResult = await errore.tryAsync(() => {
+            return getClient().session.messages({
+                sessionID: session.id,
+                directory: sdkDirectory,
+            });
+        });
+        if (messagesBeforePromptResult instanceof Error) {
+            sessionLogger.log(`[SESSION IDLE] Could not snapshot pre-prompt assistant message for ${session.id}: ${messagesBeforePromptResult.message}`);
+        }
+        else {
+            const messagesBeforePrompt = messagesBeforePromptResult.data || [];
+            const baselineAssistantIds = new Set(messagesBeforePrompt
+                .filter((message) => message.info.role === 'assistant')
+                .map((message) => message.info.id));
+            sessionRunState.setBaselineAssistantIds({
+                store: mainRunStore,
+                messageIds: baselineAssistantIds,
+            });
+        }
+        // variant is accepted by the server API but not yet in the v1 SDK types
+        const variantField = earlyThinkingValue
+            ? { variant: earlyThinkingValue }
+            : {};
+        sessionRunState.markDispatching({ store: mainRunStore });
+        const response = command
+            ? await getClient().session.command({
+                sessionID: session.id,
+                directory: sdkDirectory,
+                command: command.name,
+                arguments: command.arguments,
+                agent: agentPreference,
+                ...variantField,
+            }, { signal: abortController.signal })
+            : await getClient().session.prompt({
+                sessionID: session.id,
+                directory: sdkDirectory,
+                parts,
+                system: getOpencodeSystemMessage({
+                    sessionId: session.id,
+                    channelId,
+                    guildId: thread.guildId,
+                    threadId: thread.id,
+                    worktree,
+                    channelTopic,
+                    username,
+                    userId,
+                    agents: earlyAvailableAgents,
+                }),
+                model: modelParam,
+                agent: agentPreference,
+                ...variantField,
+            }, { 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);
+            })();
+            const responseStatus = (() => {
+                const httpStatus = response.response?.status;
+                if (typeof httpStatus === 'number') {
+                    return String(httpStatus);
+                }
+                const err = response.error;
+                if (!err || typeof err !== 'object' || !('data' in err)) {
+                    return 'unknown';
+                }
+                const data = err.data;
+                if (!data ||
+                    typeof data !== 'object' ||
+                    !('statusCode' in data) ||
+                    typeof data.statusCode !== 'number') {
+                    return 'unknown';
+                }
+                return String(data.statusCode);
+            })();
+            throw new Error(`OpenCode API error (${responseStatus}): ${errorMessage}`);
+        }
+        const deferredIdleDecision = sessionRunState.markPromptResolvedAndConsumeDeferredIdle({
+            store: mainRunStore,
+        });
+        if (deferredIdleDecision === 'ignore-no-evidence') {
+            sessionLogger.log(`[SESSION IDLE] Ignoring deferred idle for ${session.id} because no current-prompt events were observed`);
+        }
+        else if (deferredIdleDecision === 'ignore-before-evidence') {
+            sessionLogger.log(`[SESSION IDLE] Ignoring deferred idle for ${session.id} because it arrived before current-prompt evidence`);
+        }
+        else if (deferredIdleDecision === 'process') {
+            sessionLogger.log(`[SESSION IDLE] Processing deferred idle for ${session.id} after prompt resolved`);
+            finishMainSessionFromIdle();
+        }
+        sessionLogger.log(`Successfully sent prompt, got response`);
+        if (originalMessage) {
+            const reactionResult = await errore.tryAsync(async () => {
+                await removeBotErrorReaction({ message: originalMessage });
+            });
+            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)) {
+        return;
+    }
+    sessionLogger.error(`ERROR: Failed to send prompt: ${promptError.message}`);
+    void notifyError(promptError, 'Failed to send prompt to OpenCode');
+    sessionLogger.log(`[ABORT] reason=error sessionId=${session.id} threadId=${thread.id} - prompt failed with error: ${promptError.message}`);
+    sessionRunState.markAborted({ store: mainRunStore });
+    abortController.abort(new SessionAbortError({ reason: 'error' }));
+    if (originalMessage) {
+        const reactionResult = await errore.tryAsync(async () => {
+            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}`);
+}