kimaki 0.26.0 → 0.28.0

package/dist/discord-bot.js

@@ -8,11 +8,12 @@
 // suppresses these when shuttingDown is already set, and we removeAllListeners()
 // before destroying the client to prevent late events from becoming uncaught.
 import { DiscordOperationError } from './errors.js';
-import { initDatabase, closeDatabase, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorkspace, setWorkspaceReady, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, consumeSessionSleepWake, deleteChannelDirectoryById, createPendingWorkspace, setWorkspaceReady, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
+import { STATUS_PREFIX } from './message-formatting.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, resolveGuildMessageMember, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
@@ -29,7 +30,7 @@ import { cancelHtmlActionsForThread } from './html-actions.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, registerVoiceStateHandler, } from './voice-handler.js';
 import {} from './session-handler/model-utils.js';
-import { getRuntime, getOrCreateRuntime, disposeRuntime, } from './session-handler/thread-session-runtime.js';
+import { getRuntime, getOrCreateRuntime, disposeRuntime, reserveThreadIngress, runInThreadIngressSlot, } from './session-handler/thread-session-runtime.js';
 import { runShellCommand } from './commands/run-command.js';
 import { registerInteractionHandler } from './interaction-handler.js';
 import { getDiscordRestApiUrl } from './discord-urls.js';
@@ -42,7 +43,7 @@ import { getDefaultKimakiDirectory, getUserProjectCount, } from './channel-manag
 import { store } from './store.js';
 import { startExternalOpencodeSessionSync, stopExternalOpencodeSessionSync, } from './external-opencode-sync.js';
 export { initDatabase, closeDatabase, getChannelDirectory, } from './database.js';
-export { initializeOpencodeForDirectory } from './opencode.js';
+export { initializeOpencodeForDirectory, assertCompatibleOpencodeVersion } from './opencode.js';
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, } from './discord-utils.js';
 export { getOpencodeSystemMessage } from './system-message.js';
 export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, createDefaultKimakiChannel, getChannelsWithDescriptions, } from './channel-management.js';
@@ -52,6 +53,7 @@ import path from 'node:path';
 import dedent from 'string-dedent';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { writeHeapSnapshot, startHeapMonitor } from './heap-monitor.js';
+import { flushCpuProfiling, startStdinCpuProfListener, stopStdinCpuProfListener, } from './cpu-profiler.js';
 import { startTaskRunner } from './task-runner.js';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
@@ -277,8 +279,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordLogger.warn(`[GATEWAY] Shard ${shardId} reconnecting: ${parts.join(', ')}`);
         if (state.attempts >= MAX_RECONNECT_ATTEMPTS) {
             discordLogger.error(`[GATEWAY] Shard ${shardId} exceeded ${MAX_RECONNECT_ATTEMPTS} reconnect attempts, self-restarting`);
-            // Self-restart: cleanup, then exit non-zero so the bin.ts wrapper
-            // restarts us. Without the wrapper this exits after logging a warning.
+            // Self-restart: cleanup, then SIGKILL so the bin.ts wrapper
+            // restarts us. Without the wrapper this dies after logging a warning.
             void selfRestart('gateway-reconnect-limit');
         }
     });
@@ -306,524 +308,554 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordLogger.error('[GATEWAY] Session invalidated by Discord');
     });
     discordClient.on(Events.MessageCreate, async (message) => {
-        try {
-            const isSelfBotMessage = Boolean(discordClient.user && message.author?.id === discordClient.user.id);
-            const promptMarker = parseEmbedFooterMarker({
-                footer: message.embeds[0]?.footer?.text,
-            });
-            const isCliInjectedPrompt = Boolean(isSelfBotMessage && isInjectedPromptMarker({ marker: promptMarker }));
-            const sessionStartSource = isCliInjectedPrompt
-                ? parseSessionStartSourceFromMarker(promptMarker)
-                : undefined;
-            const cliInjectedUsername = isCliInjectedPrompt
-                ? promptMarker?.username || 'kimaki-cli'
-                : undefined;
-            const cliInjectedUserId = isCliInjectedPrompt
-                ? promptMarker?.userId
-                : undefined;
-            const cliInjectedAgent = isCliInjectedPrompt
-                ? promptMarker?.agent
-                : undefined;
-            const cliInjectedModel = isCliInjectedPrompt
-                ? promptMarker?.model
-                : undefined;
-            const cliInjectedPermissions = isCliInjectedPrompt
-                ? promptMarker?.permissions
-                : undefined;
-            const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
-                ? promptMarker?.injectionGuardPatterns
-                : undefined;
-            const cliInjectedParentSessionId = isCliInjectedPrompt
-                ? promptMarker?.parentSessionId
-                : undefined;
-            // Always ignore our own messages (unless CLI-injected prompt above).
-            // Without this, assigning the Kimaki role to the bot itself would loop.
-            if (isSelfBotMessage && !isCliInjectedPrompt) {
-                return;
-            }
-            // Allow CLI-injected prompts from this Kimaki bot through even when role
-            // reconciliation did not give the bot the "Kimaki" role yet. Other bots
-            // still need Kimaki permission so multi-agent orchestration stays opt-in.
-            const isInjectedSelfBotMessage = isCliInjectedPrompt && message.author?.id === discordClient.user?.id;
-            if (message.author?.bot && !isInjectedSelfBotMessage) {
-                const member = await resolveGuildMessageMember(message);
-                if (!hasKimakiBotPermission(member, message.guild)) {
-                    return;
-                }
-            }
-            // Detect messages that start with a mention of another user (not the bot).
-            // In channels these are fully ignored. In threads they are added to the
-            // session context without triggering the AI (noReply), so the agent sees
-            // user-to-user conversation on the next real turn.
-            const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/);
-            const isLeadingMentionToOtherUser = leadingMentionMatch &&
-                leadingMentionMatch[1] !== discordClient.user?.id;
-            if (message.partial) {
-                discordLogger.log(`Fetching partial message ${message.id}`);
-                const fetched = await message.fetch()
-                    .catch((e) => new DiscordOperationError({ operation: 'fetchMessage', cause: e }));
-                if (fetched instanceof Error) {
-                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
+        const threadIngressSlot = message.channel.isThread() || message.channel.type === ChannelType.GuildText
+            ? reserveThreadIngress(message.channel.id)
+            : undefined;
+        await runInThreadIngressSlot(threadIngressSlot, async () => {
+            try {
+                const isSelfBotMessage = Boolean(discordClient.user && message.author?.id === discordClient.user.id);
+                const promptMarker = parseEmbedFooterMarker({
+                    footer: message.embeds[0]?.footer?.text,
+                });
+                const isCliInjectedPrompt = Boolean(isSelfBotMessage && isInjectedPromptMarker({ marker: promptMarker }));
+                const sessionStartSource = isCliInjectedPrompt
+                    ? parseSessionStartSourceFromMarker(promptMarker)
+                    : undefined;
+                const cliInjectedUsername = isCliInjectedPrompt
+                    ? promptMarker?.username || 'kimaki-cli'
+                    : undefined;
+                const cliInjectedUserId = isCliInjectedPrompt
+                    ? promptMarker?.userId
+                    : undefined;
+                const cliInjectedAgent = isCliInjectedPrompt
+                    ? promptMarker?.agent
+                    : undefined;
+                const cliInjectedModel = isCliInjectedPrompt
+                    ? promptMarker?.model
+                    : undefined;
+                const cliInjectedPermissions = isCliInjectedPrompt
+                    ? promptMarker?.permissions
+                    : undefined;
+                const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
+                    ? promptMarker?.injectionGuardPatterns
+                    : undefined;
+                const cliInjectedParentSessionId = isCliInjectedPrompt
+                    ? promptMarker?.parentSessionId
+                    : undefined;
+                // Always ignore our own messages (unless CLI-injected prompt above).
+                // Without this, assigning the Kimaki role to the bot itself would loop.
+                if (isSelfBotMessage && !isCliInjectedPrompt) {
                     return;
                 }
-            }
-            // Check mention mode BEFORE permission check for text channels.
-            // When mention mode is enabled, users without Kimaki role can message
-            // without getting a permission error - we just silently ignore.
-            const channel = message.channel;
-            // In text channels, messages starting with a mention to another user
-            // are fully ignored before any permission or mention-mode checks.
-            // This prevents permission-error replies for user-to-user conversation.
-            if (channel.type === ChannelType.GuildText && isLeadingMentionToOtherUser) {
-                return;
-            }
-            if (channel.type === ChannelType.GuildText && !isCliInjectedPrompt) {
-                const mentionModeEnabled = await getChannelMentionMode(channel.id);
-                if (mentionModeEnabled) {
-                    const botMentioned = discordClient.user && message.mentions.has(discordClient.user.id);
-                    const isShellCommand = message.content?.startsWith('!');
-                    if (!botMentioned && !isShellCommand) {
-                        voiceLogger.log(`[IGNORED] Mention mode enabled, bot not mentioned`);
+                // Allow CLI-injected prompts from this Kimaki bot through even when role
+                // reconciliation did not give the bot the "Kimaki" role yet. Other bots
+                // still need Kimaki permission so multi-agent orchestration stays opt-in.
+                const isInjectedSelfBotMessage = isCliInjectedPrompt && message.author?.id === discordClient.user?.id;
+                if (message.author?.bot && !isInjectedSelfBotMessage) {
+                    const member = await resolveGuildMessageMember(message);
+                    if (!hasKimakiBotPermission(member, message.guild)) {
                         return;
                     }
                 }
-            }
-            // Multi-machine routing: check channel ownership before permission
-            // checks so we don't send permission-denial replies in channels owned
-            // by another machine. Resolve the "owning" channel: for threads, check
-            // the parent channel; for text channels, check the channel itself.
-            if (!isCliInjectedPrompt && message.guild) {
-                const channel = message.channel;
-                let owningChannelId;
-                if ([
-                    ChannelType.PublicThread,
-                    ChannelType.PrivateThread,
-                    ChannelType.AnnouncementThread,
-                ].includes(channel.type)) {
-                    const thread = channel;
-                    owningChannelId = thread.parent?.id || thread.parentId || undefined;
-                }
-                else {
-                    owningChannelId = channel.id;
-                }
-                if (owningChannelId) {
-                    const channelConfig = await getChannelDirectory(owningChannelId);
-                    if (!channelConfig) {
-                        voiceLogger.log(`[IGNORED] Channel ${owningChannelId} has no project directory configured`);
+                // Detect messages that start with a mention of another user (not the bot).
+                // In channels these are fully ignored. In threads they are added to the
+                // session context without triggering the AI (noReply), so the agent sees
+                // user-to-user conversation on the next real turn.
+                const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/);
+                const isLeadingMentionToOtherUser = leadingMentionMatch &&
+                    leadingMentionMatch[1] !== discordClient.user?.id;
+                if (message.partial) {
+                    discordLogger.log(`Fetching partial message ${message.id}`);
+                    const fetched = await message.fetch()
+                        .catch((e) => new DiscordOperationError({ operation: 'fetchMessage', cause: e }));
+                    if (fetched instanceof Error) {
+                        discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                         return;
                     }
                 }
-            }
-            if (!isCliInjectedPrompt && message.guild) {
-                const member = await resolveGuildMessageMember(message);
-                if (!member) {
-                    return;
-                }
-                if (hasNoKimakiRole(member)) {
-                    await message.reply({
-                        content: `You have the **no-kimaki** role which blocks bot access.\nRemove this role to use Kimaki.`,
-                        flags: SILENT_MESSAGE_FLAGS,
-                    });
-                    return;
-                }
-                if (!hasKimakiBotPermission(member, message.guild)) {
-                    await message.reply({
-                        content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
-                        flags: SILENT_MESSAGE_FLAGS,
-                    });
-                    return;
-                }
-            }
-            const isThread = [
-                ChannelType.PublicThread,
-                ChannelType.PrivateThread,
-                ChannelType.AnnouncementThread,
-            ].includes(channel.type);
-            if (isThread) {
-                const thread = channel;
-                discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
-                // Only respond in threads kimaki knows about (has a session row in DB),
-                // where the bot is explicitly @mentioned, or where the bot created the
-                // thread itself (e.g. /new-worktree, /fork, kimaki send). This prevents
-                // the bot from hijacking user-created threads in project channels while
-                // still responding to bot-created threads that may not yet have a session
-                // row with a non-empty session_id (createPendingWorkspace sets ''). (GitHub #84)
-                const hasExistingSession = await getThreadSession(thread.id);
-                const botMentioned = discordClient.user && message.mentions.has(discordClient.user.id);
-                const botCreatedThread = discordClient.user && thread.ownerId === discordClient.user.id;
-                if (!hasExistingSession &&
-                    !botMentioned &&
-                    !isCliInjectedPrompt &&
-                    !botCreatedThread) {
-                    discordLogger.log(`Ignoring thread ${thread.id}: no existing session and bot not mentioned`);
+                // Check mention mode BEFORE permission check for text channels.
+                // When mention mode is enabled, users without Kimaki role can message
+                // without getting a permission error - we just silently ignore.
+                const channel = message.channel;
+                // In text channels, messages starting with a mention to another user
+                // are fully ignored before any permission or mention-mode checks.
+                // This prevents permission-error replies for user-to-user conversation.
+                if (channel.type === ChannelType.GuildText && isLeadingMentionToOtherUser) {
                     return;
                 }
-                // Context-only messages (user-to-user replies) can't be stored without
-                // an existing session. Skip early to avoid creating a runtime or running
-                // preprocessing for nothing.
-                if (isLeadingMentionToOtherUser && !hasExistingSession) {
-                    return;
+                if (channel.type === ChannelType.GuildText && !isCliInjectedPrompt) {
+                    const mentionModeEnabled = await getChannelMentionMode(channel.id);
+                    if (mentionModeEnabled) {
+                        const botMentioned = discordClient.user && message.mentions.has(discordClient.user.id);
+                        const isShellCommand = message.content?.startsWith('!');
+                        if (!botMentioned && !isShellCommand) {
+                            voiceLogger.log(`[IGNORED] Mention mode enabled, bot not mentioned`);
+                            return;
+                        }
+                    }
                 }
-                const parent = thread.parent;
-                let projectDirectory;
-                if (parent) {
-                    const channelConfig = await getChannelDirectory(parent.id);
-                    if (channelConfig) {
-                        projectDirectory = channelConfig.directory;
+                // Multi-machine routing: check channel ownership before permission
+                // checks so we don't send permission-denial replies in channels owned
+                // by another machine. Resolve the "owning" channel: for threads, check
+                // the parent channel; for text channels, check the channel itself.
+                if (!isCliInjectedPrompt && message.guild) {
+                    const channel = message.channel;
+                    let owningChannelId;
+                    if ([
+                        ChannelType.PublicThread,
+                        ChannelType.PrivateThread,
+                        ChannelType.AnnouncementThread,
+                    ].includes(channel.type)) {
+                        const thread = channel;
+                        owningChannelId = thread.parent?.id || thread.parentId || undefined;
+                    }
+                    else {
+                        owningChannelId = channel.id;
+                    }
+                    if (owningChannelId) {
+                        const channelConfig = await getChannelDirectory(owningChannelId);
+                        if (!channelConfig) {
+                            voiceLogger.log(`[IGNORED] Channel ${owningChannelId} has no project directory configured`);
+                            return;
+                        }
                     }
                 }
-                // Check if this thread is a worktree thread.
-                // When the runtime exists in memory, pending worktrees are handled by
-                // the preprocess chain (messages queue behind the worktree promise).
-                // After a bot restart the runtime is gone, so we must reject messages
-                // for pending worktrees to avoid running in the base directory.
-                // Check both thread_workspaces (new) and thread_worktrees (legacy)
-                const worktreeInfo = await getThreadWorktreeOrWorkspace(thread.id);
-                if (worktreeInfo) {
-                    if (worktreeInfo.status === 'pending' && !getRuntime(thread.id)) {
+                if (!isCliInjectedPrompt && message.guild) {
+                    const member = await resolveGuildMessageMember(message);
+                    if (!member) {
+                        return;
+                    }
+                    if (hasNoKimakiRole(member)) {
+                        await message.reply({
+                            content: `You have the **no-kimaki** role which blocks bot access.\nRemove this role to use Kimaki.`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    if (!hasKimakiBotPermission(member, message.guild)) {
                         await message.reply({
-                            content: '⏳ Worktree is still being created. Please wait...',
+                            content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
                             flags: SILENT_MESSAGE_FLAGS,
                         });
                         return;
                     }
-                    if (worktreeInfo.status === 'error') {
+                }
+                const isThread = [
+                    ChannelType.PublicThread,
+                    ChannelType.PrivateThread,
+                    ChannelType.AnnouncementThread,
+                ].includes(channel.type);
+                if (isThread) {
+                    const thread = channel;
+                    discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
+                    // Only respond in threads kimaki knows about (has a session row in DB),
+                    // where the bot is explicitly @mentioned, or where the bot created the
+                    // thread itself (e.g. /new-worktree, /fork, kimaki send). This prevents
+                    // the bot from hijacking user-created threads in project channels while
+                    // still responding to bot-created threads that may not yet have a session
+                    // row with a non-empty session_id (createPendingWorkspace sets ''). (GitHub #84)
+                    const hasExistingSession = await getThreadSession(thread.id);
+                    const botMentioned = discordClient.user && message.mentions.has(discordClient.user.id);
+                    const botCreatedThread = discordClient.user && thread.ownerId === discordClient.user.id;
+                    if (!hasExistingSession &&
+                        !botMentioned &&
+                        !isCliInjectedPrompt &&
+                        !botCreatedThread) {
+                        discordLogger.log(`Ignoring thread ${thread.id}: no existing session and bot not mentioned`);
+                        return;
+                    }
+                    // Context-only messages (user-to-user replies) can't be stored without
+                    // an existing session. Skip early to avoid creating a runtime or running
+                    // preprocessing for nothing.
+                    if (isLeadingMentionToOtherUser && !hasExistingSession) {
+                        return;
+                    }
+                    const parent = thread.parent;
+                    let projectDirectory;
+                    if (parent) {
+                        const channelConfig = await getChannelDirectory(parent.id);
+                        if (channelConfig) {
+                            projectDirectory = channelConfig.directory;
+                        }
+                    }
+                    // Check if this thread is a worktree thread.
+                    // When the runtime exists in memory, pending worktrees are handled by
+                    // the preprocess chain (messages queue behind the worktree promise).
+                    // After a bot restart the runtime is gone, so we must reject messages
+                    // for pending worktrees to avoid running in the base directory.
+                    // Check both thread_workspaces (new) and thread_worktrees (legacy)
+                    const worktreeInfo = await getThreadWorktreeOrWorkspace(thread.id);
+                    if (worktreeInfo) {
+                        if (worktreeInfo.status === 'pending' && !getRuntime(thread.id)) {
+                            await message.reply({
+                                content: '⏳ Worktree is still being created. Please wait...',
+                                flags: SILENT_MESSAGE_FLAGS,
+                            });
+                            return;
+                        }
+                        if (worktreeInfo.status === 'error') {
+                            await message.reply({
+                                content: `❌ Worktree creation failed: ${(worktreeInfo.error_message || '').slice(0, 1900)}`,
+                                flags: NOTIFY_MESSAGE_FLAGS,
+                            });
+                            return;
+                        }
+                        // Use original project directory for OpenCode server (session lives there)
+                        // The worktree directory is passed via query.directory in prompt/command calls
+                        if (worktreeInfo.project_directory) {
+                            projectDirectory = worktreeInfo.project_directory;
+                            discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.workspace_directory})`);
+                        }
+                    }
+                    if (projectDirectory && !fs.existsSync(projectDirectory)) {
+                        discordLogger.error(`Directory does not exist: ${projectDirectory}`);
                         await message.reply({
-                            content: `❌ Worktree creation failed: ${(worktreeInfo.error_message || '').slice(0, 1900)}`,
+                            content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory).slice(0, 1900)}`,
                             flags: NOTIFY_MESSAGE_FLAGS,
                         });
                         return;
                     }
-                    // Use original project directory for OpenCode server (session lives there)
-                    // The worktree directory is passed via query.directory in prompt/command calls
-                    if (worktreeInfo.project_directory) {
-                        projectDirectory = worktreeInfo.project_directory;
-                        discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.workspace_directory})`);
+                    // ! prefix runs a shell command instead of starting/continuing a session.
+                    // Use worktree directory if available, so commands run in the worktree cwd.
+                    // Skip shell commands while worktree is pending — they'd run in the base dir.
+                    if (message.content?.startsWith('!') &&
+                        projectDirectory &&
+                        worktreeInfo?.status !== 'pending') {
+                        const shellCmd = message.content.slice(1).trim();
+                        if (shellCmd) {
+                            threadIngressSlot?.release();
+                            const shellDir = worktreeInfo?.status === 'ready' &&
+                                worktreeInfo.workspace_directory
+                                ? worktreeInfo.workspace_directory
+                                : projectDirectory;
+                            const loadingReply = await message.reply({
+                                content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
+                            });
+                            const result = await runShellCommand({
+                                command: shellCmd,
+                                directory: shellDir,
+                            });
+                            await loadingReply.edit({ content: result });
+                            return;
+                        }
                     }
-                }
-                if (projectDirectory && !fs.existsSync(projectDirectory)) {
-                    discordLogger.error(`Directory does not exist: ${projectDirectory}`);
-                    await message.reply({
-                        content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory).slice(0, 1900)}`,
-                        flags: NOTIFY_MESSAGE_FLAGS,
-                    });
-                    return;
-                }
-                // ! prefix runs a shell command instead of starting/continuing a session.
-                // Use worktree directory if available, so commands run in the worktree cwd.
-                // Skip shell commands while worktree is pending — they'd run in the base dir.
-                if (message.content?.startsWith('!') &&
-                    projectDirectory &&
-                    worktreeInfo?.status !== 'pending') {
-                    const shellCmd = message.content.slice(1).trim();
-                    if (shellCmd) {
-                        const shellDir = worktreeInfo?.status === 'ready' &&
+                    // `. btw` suffix mirrors /btw for fast side-question forks.
+                    // Works like queue: just the word "btw" at the end after punctuation
+                    // or newline. The whole message (minus the suffix) becomes the fork prompt.
+                    const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
+                        ? extractBtwSuffix(message.content || '')
+                        : null;
+                    if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
+                        threadIngressSlot?.release();
+                        const btwSdkDir = worktreeInfo?.status === 'ready' &&
                             worktreeInfo.workspace_directory
                             ? worktreeInfo.workspace_directory
                             : projectDirectory;
-                        const loadingReply = await message.reply({
-                            content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
+                        const result = await forkSessionToBtwThread({
+                            sourceThread: thread,
+                            projectDirectory,
+                            sdkDirectory: btwSdkDir,
+                            prompt: btwResult.prompt,
+                            userId: message.author.id,
+                            username: message.member?.displayName || message.author.displayName,
+                            appId: currentAppId,
                         });
-                        const result = await runShellCommand({
-                            command: shellCmd,
-                            directory: shellDir,
+                        if (result instanceof Error) {
+                            await message.reply({
+                                content: result.message,
+                                flags: SILENT_MESSAGE_FLAGS,
+                            });
+                            return;
+                        }
+                        await message.reply({
+                            content: `Session forked! Continue in ${result.thread.toString()}`,
+                            flags: SILENT_MESSAGE_FLAGS,
                         });
-                        await loadingReply.edit({ content: result });
                         return;
                     }
-                }
-                // `. btw` suffix mirrors /btw for fast side-question forks.
-                // Works like queue: just the word "btw" at the end after punctuation
-                // or newline. The whole message (minus the suffix) becomes the fork prompt.
-                const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
-                    ? extractBtwSuffix(message.content || '')
-                    : null;
-                if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
-                    const btwSdkDir = worktreeInfo?.status === 'ready' &&
-                        worktreeInfo.workspace_directory
-                        ? worktreeInfo.workspace_directory
-                        : projectDirectory;
-                    const result = await forkSessionToBtwThread({
-                        sourceThread: thread,
-                        projectDirectory,
-                        sdkDirectory: btwSdkDir,
-                        prompt: btwResult.prompt,
-                        userId: message.author.id,
-                        username: message.member?.displayName || message.author.displayName,
-                        appId: currentAppId,
+                    const hasVoiceAttachment = message.attachments.some((attachment) => {
+                        return isVoiceAttachment(attachment);
                     });
-                    if (result instanceof Error) {
+                    if (!projectDirectory) {
+                        discordLogger.log(`Cannot process message: no project directory for thread ${thread.id}`);
+                        return;
+                    }
+                    if (isMissingReadableMessageContent(message)) {
                         await message.reply({
-                            content: result.message,
+                            content: MISSING_MESSAGE_CONTENT_REPLY,
                             flags: SILENT_MESSAGE_FLAGS,
                         });
                         return;
                     }
-                    await message.reply({
-                        content: `Session forked! Continue in ${result.thread.toString()}`,
-                        flags: SILENT_MESSAGE_FLAGS,
-                    });
-                    return;
-                }
-                const hasVoiceAttachment = message.attachments.some((attachment) => {
-                    return isVoiceAttachment(attachment);
-                });
-                if (!projectDirectory) {
-                    discordLogger.log(`Cannot process message: no project directory for thread ${thread.id}`);
-                    return;
-                }
-                if (isMissingReadableMessageContent(message)) {
-                    await message.reply({
-                        content: MISSING_MESSAGE_CONTENT_REPLY,
-                        flags: SILENT_MESSAGE_FLAGS,
+                    const resolvedProjectDir = projectDirectory;
+                    const sdkDir = worktreeInfo?.status === 'ready' &&
+                        worktreeInfo.workspace_directory
+                        ? worktreeInfo.workspace_directory
+                        : resolvedProjectDir;
+                    const runtime = getOrCreateRuntime({
+                        threadId: thread.id,
+                        thread,
+                        projectDirectory: resolvedProjectDir,
+                        sdkDirectory: sdkDir,
+                        channelId: parent?.id || undefined,
+                        appId: currentAppId,
                     });
-                    return;
-                }
-                const resolvedProjectDir = projectDirectory;
-                const sdkDir = worktreeInfo?.status === 'ready' &&
-                    worktreeInfo.workspace_directory
-                    ? worktreeInfo.workspace_directory
-                    : resolvedProjectDir;
-                const runtime = getOrCreateRuntime({
-                    threadId: thread.id,
-                    thread,
-                    projectDirectory: resolvedProjectDir,
-                    sdkDirectory: sdkDir,
-                    channelId: parent?.id || undefined,
-                    appId: currentAppId,
-                });
-                // Cancel interactive UI when a real user sends a message.
-                // Context-only messages (user-to-user replies) should not interrupt
-                // the active run or dismiss pending UI.
-                if (!message.author.bot && !isCliInjectedPrompt && !isLeadingMentionToOtherUser) {
-                    cancelPendingActionButtons(thread.id);
-                    cancelHtmlActionsForThread(thread.id);
-                    const dismissedPermission = await cancelPendingPermission(thread.id);
-                    if (dismissedPermission) {
-                        await runtime.abortActiveRunAndWait({
-                            reason: 'user sent a new message while permission was pending',
-                        });
+                    // Cancel interactive UI when a real user sends a message.
+                    // Context-only messages (user-to-user replies) should not interrupt
+                    // the active run or dismiss pending UI.
+                    const dismissSourceUi = async () => {
+                        if (message.author.bot || isCliInjectedPrompt || isLeadingMentionToOtherUser)
+                            return;
+                        cancelPendingActionButtons(thread.id);
+                        cancelHtmlActionsForThread(thread.id);
+                        const dismissedPermission = await cancelPendingPermission(thread.id);
+                        if (dismissedPermission) {
+                            await runtime.abortActiveRunAndWait({
+                                reason: 'user sent a new message while permission was pending',
+                            });
+                        }
+                        const dismissedQuestion = hasPendingQuestionForThread(thread.id);
+                        if (dismissedQuestion) {
+                            await cancelPendingQuestion(thread.id);
+                            await runtime.abortActiveRunAndWait({
+                                reason: 'user sent a new message while question was pending',
+                            });
+                        }
+                        void cancelPendingFileUpload(thread.id);
+                    };
+                    if (!hasVoiceAttachment) {
+                        await dismissSourceUi();
                     }
-                    const dismissedQuestion = hasPendingQuestionForThread(thread.id);
-                    if (dismissedQuestion) {
-                        await cancelPendingQuestion(thread.id);
-                        await runtime.abortActiveRunAndWait({
-                            reason: 'user sent a new message while question was pending',
-                        });
+                    // A sleep wake only becomes a turn if it can still claim its own row.
+                    // The claim fails when the user cancelled the sleep while the wake was
+                    // being posted, so the superseded wake is dropped instead of starting a
+                    // turn the user already replaced. Cancellation for every other kind of
+                    // message happens inside runtime.enqueueIncoming().
+                    const isSleepWake = Boolean(promptMarker?.sleepWake);
+                    if (isSleepWake) {
+                        const claimedWake = promptMarker?.sleepId
+                            ? await consumeSessionSleepWake({ deliveryId: promptMarker.sleepId })
+                            : false;
+                        if (!claimedWake) {
+                            discordLogger.log(`[SLEEP] ignoring superseded wake in thread ${thread.id}`);
+                            return;
+                        }
+                    }
+                    // Expensive pre-processing (voice transcription, context fetch,
+                    // attachment download) runs inside the runtime's serialized
+                    // preprocess chain, preserving Discord arrival order without
+                    // blocking SSE event handling in dispatchAction.
+                    const enqueueResult = await runtime.enqueueIncoming({
+                        prompt: '',
+                        userId: cliInjectedUserId || message.author.id,
+                        username: cliInjectedUsername ||
+                            message.member?.displayName ||
+                            message.author.displayName,
+                        sourceMessageId: message.id,
+                        sourceThreadId: thread.id,
+                        appId: currentAppId,
+                        agent: cliInjectedAgent,
+                        model: cliInjectedModel,
+                        permissions: cliInjectedPermissions,
+                        injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                        parentSessionId: cliInjectedParentSessionId,
+                        isSleepWake: isSleepWake || undefined,
+                        noReply: isLeadingMentionToOtherUser || undefined,
+                        sessionStartSource: sessionStartSource
+                            ? {
+                                scheduleKind: sessionStartSource.scheduleKind,
+                                scheduledTaskId: sessionStartSource.scheduledTaskId,
+                                scheduledTaskRunId: sessionStartSource.scheduledTaskRunId,
+                            }
+                            : undefined,
+                        preprocess: async () => {
+                            const result = await preprocessExistingThreadMessage({
+                                message,
+                                thread,
+                                projectDirectory: resolvedProjectDir,
+                                channelId: parent?.id || undefined,
+                                isCliInjected: isCliInjectedPrompt,
+                                hasVoiceAttachment,
+                                appId: currentAppId,
+                            });
+                            // Routing must finish before touching source UI. This chain is separate
+                            // from dispatchAction, so abort waiting does not block session events.
+                            if (hasVoiceAttachment && !result.skip) {
+                                await dismissSourceUi();
+                            }
+                            return result;
+                        },
+                    });
+                    // Notify when a voice message was queued instead of sent immediately
+                    if (enqueueResult.queued && enqueueResult.position) {
+                        await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`);
                     }
-                    void cancelPendingFileUpload(thread.id);
                 }
-                // Expensive pre-processing (voice transcription, context fetch,
-                // attachment download) runs inside the runtime's serialized
-                // preprocess chain, preserving Discord arrival order without
-                // blocking SSE event handling in dispatchAction.
-                const enqueueResult = await runtime.enqueueIncoming({
-                    prompt: '',
-                    userId: cliInjectedUserId || message.author.id,
-                    username: cliInjectedUsername ||
-                        message.member?.displayName ||
-                        message.author.displayName,
-                    sourceMessageId: message.id,
-                    sourceThreadId: thread.id,
-                    appId: currentAppId,
-                    agent: cliInjectedAgent,
-                    model: cliInjectedModel,
-                    permissions: cliInjectedPermissions,
-                    injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
-                    parentSessionId: cliInjectedParentSessionId,
-                    noReply: isLeadingMentionToOtherUser || undefined,
-                    sessionStartSource: sessionStartSource
-                        ? {
-                            scheduleKind: sessionStartSource.scheduleKind,
-                            scheduledTaskId: sessionStartSource.scheduledTaskId,
-                            scheduledTaskRunId: sessionStartSource.scheduledTaskRunId,
+                if (channel.type === ChannelType.GuildText) {
+                    // `kimaki send` posts a starter message with a `start` embed marker,
+                    // then creates the thread via REST. The ThreadCreate handler picks up
+                    // that thread and starts the session. If we don't skip here, this
+                    // handler races the CLI to call startThread() on the same message,
+                    // causing DiscordAPIError[160004] "A thread has already been created
+                    // for this message".
+                    if (promptMarker?.start) {
+                        return;
+                    }
+                    voiceLogger.log(`[GUILD_TEXT] Message in text channel #${channel.name} (${channel.id})`);
+                    const channelConfig = await getChannelDirectory(channel.id);
+                    if (!channelConfig) {
+                        const botMentioned = Boolean(discordClient.user && message.mentions.has(discordClient.user.id));
+                        if (botMentioned) {
+                            // TODO: Consider creating/using a session for any text channel when Kimaki is
+                            // explicitly @mentioned, so the bot can answer quick questions even before
+                            // the channel is linked to a project.
+                            await message.reply({
+                                content: 'This channel is not connected to an OpenCode project.\nSend your message in a project channel, or use `/add-project` for an existing project, or `/create-new-project` to make a new one.',
+                                flags: SILENT_MESSAGE_FLAGS,
+                            });
+                            return;
                         }
-                        : undefined,
-                    preprocess: () => {
-                        return preprocessExistingThreadMessage({
-                            message,
-                            thread,
-                            projectDirectory: resolvedProjectDir,
-                            channelId: parent?.id || undefined,
-                            isCliInjected: isCliInjectedPrompt,
-                            hasVoiceAttachment,
-                            appId: currentAppId,
+                        voiceLogger.log(`[IGNORED] Channel #${channel.name} has no project directory configured`);
+                        return;
+                    }
+                    const projectDirectory = channelConfig.directory;
+                    // Note: Mention mode is checked early in the handler (before permission check)
+                    // to avoid sending permission errors to users who just didn't @mention the bot.
+                    discordLogger.log(`DIRECTORY: Found kimaki.directory: ${projectDirectory}`);
+                    if (!fs.existsSync(projectDirectory)) {
+                        discordLogger.error(`Directory does not exist: ${projectDirectory}`);
+                        await message.reply({
+                            content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory).slice(0, 1900)}`,
+                            flags: NOTIFY_MESSAGE_FLAGS,
                         });
-                    },
-                });
-                // Notify when a voice message was queued instead of sent immediately
-                if (enqueueResult.queued && enqueueResult.position) {
-                    await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`);
-                }
-            }
-            if (channel.type === ChannelType.GuildText) {
-                // `kimaki send` posts a starter message with a `start` embed marker,
-                // then creates the thread via REST. The ThreadCreate handler picks up
-                // that thread and starts the session. If we don't skip here, this
-                // handler races the CLI to call startThread() on the same message,
-                // causing DiscordAPIError[160004] "A thread has already been created
-                // for this message".
-                if (promptMarker?.start) {
-                    return;
-                }
-                voiceLogger.log(`[GUILD_TEXT] Message in text channel #${channel.name} (${channel.id})`);
-                const channelConfig = await getChannelDirectory(channel.id);
-                if (!channelConfig) {
-                    const botMentioned = Boolean(discordClient.user && message.mentions.has(discordClient.user.id));
-                    if (botMentioned) {
-                        // TODO: Consider creating/using a session for any text channel when Kimaki is
-                        // explicitly @mentioned, so the bot can answer quick questions even before
-                        // the channel is linked to a project.
+                        return;
+                    }
+                    if (isMissingReadableMessageContent(message)) {
                         await message.reply({
-                            content: 'This channel is not connected to an OpenCode project.\nSend your message in a project channel, or use `/add-project` for an existing project, or `/create-new-project` to make a new one.',
+                            content: MISSING_MESSAGE_CONTENT_REPLY,
                             flags: SILENT_MESSAGE_FLAGS,
                         });
                         return;
                     }
-                    voiceLogger.log(`[IGNORED] Channel #${channel.name} has no project directory configured`);
-                    return;
-                }
-                const projectDirectory = channelConfig.directory;
-                // Note: Mention mode is checked early in the handler (before permission check)
-                // to avoid sending permission errors to users who just didn't @mention the bot.
-                discordLogger.log(`DIRECTORY: Found kimaki.directory: ${projectDirectory}`);
-                if (!fs.existsSync(projectDirectory)) {
-                    discordLogger.error(`Directory does not exist: ${projectDirectory}`);
-                    await message.reply({
-                        content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory).slice(0, 1900)}`,
-                        flags: NOTIFY_MESSAGE_FLAGS,
+                    // ! prefix runs a shell command instead of starting a session
+                    if (message.content?.startsWith('!')) {
+                        const shellCmd = message.content.slice(1).trim();
+                        if (shellCmd) {
+                            threadIngressSlot?.release();
+                            const loadingReply = await message.reply({
+                                content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
+                            });
+                            const result = await runShellCommand({
+                                command: shellCmd,
+                                directory: projectDirectory,
+                            });
+                            await loadingReply.edit({ content: result });
+                            return;
+                        }
+                    }
+                    const hasVoice = message.attachments.some((attachment) => {
+                        return isVoiceAttachment(attachment);
                     });
-                    return;
-                }
-                if (isMissingReadableMessageContent(message)) {
-                    await message.reply({
-                        content: MISSING_MESSAGE_CONTENT_REPLY,
-                        flags: SILENT_MESSAGE_FLAGS,
+                    const baseThreadName = hasVoice
+                        ? 'Voice Message'
+                        : stripMentions(message.content || '')
+                            .replace(/\s+/g, ' ')
+                            .trim() || 'kimaki thread';
+                    // Check if worktrees should be enabled (CLI flag OR channel setting).
+                    // Only create worktrees from the configured project directory when that
+                    // directory is itself the git root. If the user registered a non-git
+                    // workspace folder under a larger repo, git would create the worktree
+                    // from the parent repo and strand follow-up messages on failure.
+                    const wantsWorktrees = useWorktrees || (await getChannelWorktreesEnabled(channel.id));
+                    const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+                    if (wantsWorktrees && !shouldUseWorktrees) {
+                        discordLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+                    }
+                    // Add worktree prefix if worktrees are enabled
+                    const threadName = shouldUseWorktrees
+                        ? `${WORKTREE_PREFIX}${baseThreadName}`
+                        : baseThreadName;
+                    const thread = await message.startThread({
+                        name: threadName.slice(0, 80),
+                        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+                        reason: 'Start Claude session',
                     });
-                    return;
-                }
-                // ! prefix runs a shell command instead of starting a session
-                if (message.content?.startsWith('!')) {
-                    const shellCmd = message.content.slice(1).trim();
-                    if (shellCmd) {
-                        const loadingReply = await message.reply({
-                            content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
-                        });
-                        const result = await runShellCommand({
-                            command: shellCmd,
-                            directory: projectDirectory,
+                    // Add user to thread so it appears in their sidebar
+                    await thread.members.add(message.author.id);
+                    discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
+                    // Create runtime immediately so follow-up messages queue naturally
+                    // via the preprocess chain instead of being rejected with "please wait".
+                    // When worktrees are enabled, the worktree promise runs concurrently
+                    // and the first message's preprocess callback awaits it before resolving.
+                    let worktreePromise;
+                    if (shouldUseWorktrees) {
+                        // Auto-derived from thread name -- compress long slugs so the
+                        // folder path stays short and the agent doesn't reuse old worktrees.
+                        const worktreeName = formatAutoWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
+                        discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+                        const worktreeStatusMessage = await thread
+                            .send({
+                            content: worktreeCreatingMessage(worktreeName),
+                            flags: SILENT_MESSAGE_FLAGS,
+                        })
+                            .catch(() => undefined);
+                        worktreePromise = createWorktreeInBackground({
+                            thread,
+                            starterMessage: worktreeStatusMessage,
+                            worktreeName,
+                            projectDirectory,
+                            rest: discordClient.rest,
                         });
-                        await loadingReply.edit({ content: result });
-                        return;
                     }
-                }
-                const hasVoice = message.attachments.some((attachment) => {
-                    return isVoiceAttachment(attachment);
-                });
-                const baseThreadName = hasVoice
-                    ? 'Voice Message'
-                    : stripMentions(message.content || '')
-                        .replace(/\s+/g, ' ')
-                        .trim() || 'kimaki thread';
-                // Check if worktrees should be enabled (CLI flag OR channel setting).
-                // Only create worktrees from the configured project directory when that
-                // directory is itself the git root. If the user registered a non-git
-                // workspace folder under a larger repo, git would create the worktree
-                // from the parent repo and strand follow-up messages on failure.
-                const wantsWorktrees = useWorktrees || (await getChannelWorktreesEnabled(channel.id));
-                const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
-                if (wantsWorktrees && !shouldUseWorktrees) {
-                    discordLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
-                }
-                // Add worktree prefix if worktrees are enabled
-                const threadName = shouldUseWorktrees
-                    ? `${WORKTREE_PREFIX}${baseThreadName}`
-                    : baseThreadName;
-                const thread = await message.startThread({
-                    name: threadName.slice(0, 80),
-                    autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-                    reason: 'Start Claude session',
-                });
-                // Add user to thread so it appears in their sidebar
-                await thread.members.add(message.author.id);
-                discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
-                // Create runtime immediately so follow-up messages queue naturally
-                // via the preprocess chain instead of being rejected with "please wait".
-                // When worktrees are enabled, the worktree promise runs concurrently
-                // and the first message's preprocess callback awaits it before resolving.
-                let worktreePromise;
-                if (shouldUseWorktrees) {
-                    // Auto-derived from thread name -- compress long slugs so the
-                    // folder path stays short and the agent doesn't reuse old worktrees.
-                    const worktreeName = formatAutoWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
-                    discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
-                    const worktreeStatusMessage = await thread
-                        .send({
-                        content: worktreeCreatingMessage(worktreeName),
-                        flags: SILENT_MESSAGE_FLAGS,
-                    })
-                        .catch(() => undefined);
-                    worktreePromise = createWorktreeInBackground({
+                    const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory;
+                    if (worktreeResult instanceof Error)
+                        return;
+                    const sessionDirectory = worktreeResult;
+                    const channelRuntime = getOrCreateRuntime({
+                        threadId: thread.id,
                         thread,
-                        starterMessage: worktreeStatusMessage,
-                        worktreeName,
                         projectDirectory,
-                        rest: discordClient.rest,
+                        sdkDirectory: sessionDirectory,
+                        channelId: channel.id,
+                        appId: currentAppId,
+                    });
+                    await channelRuntime.enqueueIncoming({
+                        prompt: '',
+                        userId: message.author.id,
+                        username: message.member?.displayName || message.author.displayName,
+                        sourceMessageId: message.id,
+                        sourceThreadId: thread.id,
+                        appId: currentAppId,
+                        preprocess: async () => {
+                            return preprocessNewThreadMessage({
+                                message,
+                                thread,
+                                projectDirectory: sessionDirectory,
+                                hasVoiceAttachment: hasVoice,
+                                appId: currentAppId,
+                            });
+                        },
                     });
                 }
-                const sessionDirectory = await (async () => {
-                    if (!worktreePromise) {
-                        return projectDirectory;
-                    }
-                    const result = await worktreePromise;
-                    if (result instanceof Error)
-                        return projectDirectory;
-                    return result;
-                })();
-                const channelRuntime = getOrCreateRuntime({
-                    threadId: thread.id,
-                    thread,
-                    projectDirectory,
-                    sdkDirectory: sessionDirectory,
-                    channelId: channel.id,
-                    appId: currentAppId,
-                });
-                await channelRuntime.enqueueIncoming({
-                    prompt: '',
-                    userId: message.author.id,
-                    username: message.member?.displayName || message.author.displayName,
-                    sourceMessageId: message.id,
-                    sourceThreadId: thread.id,
-                    appId: currentAppId,
-                    preprocess: async () => {
-                        return preprocessNewThreadMessage({
-                            message,
-                            thread,
-                            projectDirectory: sessionDirectory,
-                            hasVoiceAttachment: hasVoice,
-                            appId: currentAppId,
-                        });
-                    },
-                });
-            }
-            else {
-                // discordLogger.log(`Channel type ${channel.type} is not supported`)
-            }
-        }
-        catch (error) {
-            voiceLogger.error('Discord handler error:', error);
-            void notifyError(error, 'MessageCreate handler error');
-            try {
-                const errMsg = (error instanceof Error ? error.message : String(error)).slice(0, 1900);
-                await message.reply({
-                    content: `Error: ${errMsg}`,
-                    flags: NOTIFY_MESSAGE_FLAGS,
-                });
+                else {
+                    // discordLogger.log(`Channel type ${channel.type} is not supported`)
+                }
             }
-            catch (sendError) {
-                voiceLogger.error('Discord handler error (fallback):', sendError instanceof Error ? sendError.message : String(sendError));
+            catch (error) {
+                voiceLogger.error('Discord handler error:', error);
+                void notifyError(error, 'MessageCreate handler error');
+                try {
+                    const errMsg = (error instanceof Error ? error.message : String(error)).slice(0, 1900);
+                    await message.reply({
+                        content: `Error: ${errMsg}`,
+                        flags: NOTIFY_MESSAGE_FLAGS,
+                    });
+                }
+                catch (sendError) {
+                    voiceLogger.error('Discord handler error (fallback):', sendError instanceof Error ? sendError.message : String(sendError));
+                }
             }
-        }
+        });
     });
     // Handle user message edits to update queued messages.
     // When a user edits a message that is still waiting in kimaki's local queue,
@@ -869,11 +901,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const displayName = message.member?.displayName ?? message.author.displayName;
                 if (result.removed) {
                     discordLogger.log(`[MESSAGE_EDIT] Removed queued message ${message.id} in thread ${channel.id}`);
-                    await sendThreadMessage(channel, `⬦ **${displayName}** removed message from queue`);
+                    await sendThreadMessage(channel, `${STATUS_PREFIX}**${displayName}** removed message from queue`);
                 }
                 else {
                     discordLogger.log(`[MESSAGE_EDIT] Updated queued message ${message.id} in thread ${channel.id}`);
-                    await sendThreadMessage(channel, `⬦ **${displayName}** edited queued message`);
+                    await sendThreadMessage(channel, `${STATUS_PREFIX}**${displayName}** edited queued message`);
                 }
             }
         }
@@ -896,7 +928,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (!removed)
                 return;
             discordLogger.log(`[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`);
-            await sendThreadMessage(channel, `⬦ **${removed.username}** removed message from queue`);
+            await sendThreadMessage(channel, `${STATUS_PREFIX}**${removed.username}** removed message from queue`);
         }
         catch (error) {
             discordLogger.error('Error handling message delete:', error instanceof Error ? error.stack : String(error));
@@ -1055,18 +1087,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
             discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
             const botThreadStartSource = parseSessionStartSourceFromMarker(marker);
-            const sessionDirectory = await (async () => {
-                if (cwdDirectory) {
-                    return cwdDirectory;
-                }
-                if (!worktreePromise) {
-                    return projectDirectory;
-                }
-                const result = await worktreePromise;
-                if (result instanceof Error)
-                    return projectDirectory;
-                return result;
-            })();
+            const worktreeResult = worktreePromise ? await worktreePromise : undefined;
+            if (worktreeResult instanceof Error)
+                return;
+            const sessionDirectory = cwdDirectory ?? worktreeResult ?? projectDirectory;
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
@@ -1151,6 +1175,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         await discordClient.login(token);
     }
     startHeapMonitor();
+    startStdinCpuProfListener();
     const stopTaskRunner = startTaskRunner({ token });
     const stopRuntimeIdleSweeper = startRuntimeIdleSweeper();
     // Prevent discord.js from permanently killing the REST token on 401.
@@ -1175,6 +1200,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         global.shuttingDown = true;
         try {
+            stopStdinCpuProfListener();
+            const flushed = await flushCpuProfiling();
+            if (flushed instanceof Error) {
+                discordLogger.warn('Failed to flush CPU profile on shutdown:', flushed.message);
+            }
             await stopRuntimeIdleSweeper();
             await stopTaskRunner();
             await flushDebouncedProcessCallbacks().catch((error) => {
@@ -1244,13 +1274,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
         });
     });
-    // Self-restart: exit with code 1 so the bin.ts wrapper restarts us with
-    // exponential backoff and crash-loop detection. When running without the
-    // wrapper (e.g. `tsx src/cli.ts`), the process just exits and the user
-    // sees the non-zero exit code — they should use `tsx src/bin.ts` instead
-    // for auto-restart support. The previous detached-spawn fallback was
-    // unreliable: process.exit(0) could kill the child before it started,
-    // there was no backoff between restarts, and spawn failures were silent.
+    // Self-restart: die so the bin.ts wrapper restarts us with exponential
+    // backoff and crash-loop detection. process.exit() can hang joining native
+    // worker threads after Discord gateway failures, so SIGKILL instead.
+    // When running without the wrapper (e.g. `tsx src/cli.ts`), the process
+    // just dies — use `tsx src/bin.ts` for auto-restart support.
     let selfRestarting = false;
     async function selfRestart(reason) {
         if (selfRestarting) {
@@ -1259,6 +1287,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         selfRestarting = true;
         discordLogger.log(`Self-restarting (reason: ${reason})...`);
+        setTimeout(() => process.kill(process.pid, 'SIGKILL'), 15_000);
         try {
             await handleShutdown(reason, { skipExit: true });
         }
@@ -1268,7 +1297,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         if (!process.env.__KIMAKI_CHILD) {
             discordLogger.warn('No restart wrapper detected. Run via `tsx src/bin.ts` (dev) or `kimaki` (npm) for auto-restart on crash.');
         }
-        process.exit(1);
+        process.kill(process.pid, 'SIGKILL');
     }
     process.on('SIGUSR2', () => {
         discordLogger.log('Received SIGUSR2, restarting after cleanup...');