kimaki 0.29.0 → 0.30.0

package/dist/db.test.js

@@ -7,7 +7,7 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, deleteThreadQueueItem, getDueSessionSleeps, getSessionEventSnapshot, getSessionModel, getSessionSleep, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setSessionModel, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
 import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
@@ -60,6 +60,109 @@ describe('getDb', () => {
         expect(JSON.parse(remaining[0].payload_json).prompt).toBe('first-edited');
         await db.delete(schema.thread_queue_items).where(orm.eq(schema.thread_queue_items.thread_id, threadId));
     });
+    test('cancels channel tasks before deleting a channel mapping', async () => {
+        const channelId = `channel-${crypto.randomUUID()}`;
+        await setChannelDirectory({
+            channelId,
+            directory: `/tmp/${channelId}`,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(channelId, 'text_only');
+        const taskId = await createScheduledTask({
+            scheduleKind: 'at',
+            nextRunAt: new Date('2099-01-01T00:00:00.000Z'),
+            payloadJson: JSON.stringify({ kind: 'channel', channelId, prompt: 'later' }),
+            promptPreview: 'later',
+            channelId,
+        });
+        expect(await deleteChannelDirectoryById(channelId)).toBe(true);
+        const db = await getDb();
+        expect({
+            mapping: await getChannelDirectory(channelId),
+            task: await getScheduledTask(taskId),
+            verbosity: await db.query.channel_verbosity.findFirst({
+                where: { channel_id: channelId },
+            }),
+        }).toMatchObject({
+            mapping: undefined,
+            task: {
+                status: 'cancelled',
+                last_error: 'Discord channel was deleted',
+            },
+            verbosity: undefined,
+        });
+    });
+    test('cleans pending work when a Discord thread is deleted', async () => {
+        const threadId = `thread-${crypto.randomUUID()}`;
+        const sessionId = `session-${crypto.randomUUID()}`;
+        const queueId = `queue-${crypto.randomUUID()}`;
+        await setThreadSession(threadId, sessionId);
+        await insertThreadQueueItem({
+            queueId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'queued' }),
+        });
+        await upsertSessionSleep({
+            sessionId,
+            wakeAt: new Date('2099-01-01T00:00:00.000Z'),
+            reason: 'later',
+        });
+        const ipcRequest = await createIpcRequest({
+            type: 'file_upload',
+            sessionId,
+            threadId,
+            payload: '{}',
+        });
+        const taskId = await createScheduledTask({
+            scheduleKind: 'at',
+            nextRunAt: new Date('2099-01-01T00:00:00.000Z'),
+            payloadJson: JSON.stringify({ kind: 'thread', threadId, prompt: 'later' }),
+            promptPreview: 'later',
+            threadId,
+            sessionId,
+        });
+        await cleanupDeletedThread(threadId);
+        await completeIpcRequest({ id: ipcRequest.id, response: 'late response' });
+        expect({
+            ipc: await getIpcRequestById({ id: ipcRequest.id }),
+            queue: await listThreadQueueItems(threadId),
+            session: await getThreadSession(threadId),
+            sleep: await getSessionSleep({ sessionId }),
+            task: await getScheduledTask(taskId),
+        }).toMatchObject({
+            ipc: { status: 'cancelled' },
+            queue: [],
+            session: sessionId,
+            sleep: { status: 'cancelled' },
+            task: {
+                status: 'cancelled',
+                last_error: 'Discord thread was deleted',
+            },
+        });
+    });
+    test('deleting an old resumed thread preserves the current session sleep', async () => {
+        const db = await getDb();
+        const sessionId = `resumed-session-${crypto.randomUUID()}`;
+        const oldThreadId = `old-thread-${crypto.randomUUID()}`;
+        const currentThreadId = `current-thread-${crypto.randomUUID()}`;
+        await setThreadSession(oldThreadId, sessionId);
+        await setThreadSession(currentThreadId, sessionId);
+        await db.update(schema.thread_sessions)
+            .set({ updated_at: new Date('2020-01-01T00:00:00.000Z') })
+            .where(orm.eq(schema.thread_sessions.thread_id, oldThreadId));
+        await db.update(schema.thread_sessions)
+            .set({ updated_at: new Date('2021-01-01T00:00:00.000Z') })
+            .where(orm.eq(schema.thread_sessions.thread_id, currentThreadId));
+        await upsertSessionSleep({
+            sessionId,
+            wakeAt: new Date('2099-01-01T00:00:00.000Z'),
+            reason: 'still current',
+        });
+        await cleanupDeletedThread(oldThreadId);
+        expect(await getSessionSleep({ sessionId })).toMatchObject({
+            status: 'planned',
+        });
+    });
     test('rebuilds thread_queue_items that still use queue_id as the primary key', async () => {
         await closeDb();
         const previousDbUrl = process.env['KIMAKI_DB_URL'];

package/dist/discord-bot.js

@@ -8,12 +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, consumeSessionSleepWake, deleteChannelDirectoryById, createPendingWorkspace, setWorkspaceReady, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, cleanupDeletedThread, clearGuildCategoryByChannelId, consumeSessionSleepWake, deleteForumSyncConfig, deleteChannelDirectoryById, findChannelsByDirectory, isCurrentThreadSessionBinding, 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 { asSystemLine, 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';
@@ -30,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, restorePersistedLocalQueues, reserveThreadIngress, runInThreadIngressSlot, } from './session-handler/thread-session-runtime.js';
+import { getRuntime, getOrCreateRuntime, disposeRuntime, getRuntimeThreadIdsForChannel, restorePersistedLocalQueues, 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,6 +42,7 @@ import { startRuntimeIdleSweeper } from './runtime-idle-sweeper.js';
 import { getDefaultKimakiDirectory, getUserProjectCount, } from './channel-management.js';
 import { store } from './store.js';
 import { startExternalOpencodeSessionSync, stopExternalOpencodeSessionSync, } from './external-opencode-sync.js';
+import { stopForumSyncForChannel } from './forum-sync/watchers.js';
 export { initDatabase, closeDatabase, getChannelDirectory, } from './database.js';
 export { initializeOpencodeForDirectory, assertCompatibleOpencodeVersion } from './opencode.js';
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, } from './discord-utils.js';
@@ -182,7 +183,56 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordClient = await createDiscordClient();
     }
     store.setState({ useWorktrees: Boolean(useWorktrees) });
+    activeDiscordClient = discordClient;
+    registerBotLifecycleHandlers();
     let currentAppId = appId;
+    const cleanupDeletedDiscordThread = async (threadId) => {
+        const abortActiveRun = await isCurrentThreadSessionBinding(threadId);
+        disposeRuntime(threadId, { abortActiveRun });
+        await cleanupDeletedThread(threadId);
+    };
+    const cleanupDeletedDiscordChannel = async (channelId) => {
+        const mapping = await getChannelDirectory(channelId);
+        const preserveMapping = mapping?.directory === getDefaultKimakiDirectory();
+        const threadIds = getRuntimeThreadIdsForChannel(channelId);
+        await Promise.all(threadIds.map(cleanupDeletedDiscordThread));
+        await stopForumSyncForChannel(channelId);
+        await clearGuildCategoryByChannelId(channelId);
+        if (currentAppId) {
+            await deleteForumSyncConfig({
+                appId: currentAppId,
+                forumChannelId: channelId,
+            });
+        }
+        const deleted = await deleteChannelDirectoryById(channelId, {
+            preserveMapping,
+        });
+        if (preserveMapping) {
+            discordLogger.log(`Preserved deleted default channel ${channelId} as a tombstone`);
+            return;
+        }
+        if (deleted) {
+            discordLogger.log(`Cleaned up deleted channel ${channelId}`);
+        }
+    };
+    const reconcileDeletedDiscordChannels = async (c) => {
+        const mappings = await findChannelsByDirectory({});
+        for (const mapping of mappings) {
+            const channel = await c.channels
+                .fetch(mapping.channel_id, { force: true })
+                .catch((error) => {
+                const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
+                const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
+                if (code === 10003 || status === 404)
+                    return null;
+                discordLogger.warn(`Could not verify channel ${mapping.channel_id}; preserving its SQLite mapping: ${formatErrorWithStack(error)}`);
+                return undefined;
+            });
+            if (channel !== null)
+                continue;
+            await cleanupDeletedDiscordChannel(mapping.channel_id);
+        }
+    };
     const setupHandlers = async (c) => {
         discordLogger.log(`Discord bot logged in as ${c.user.tag}`);
         discordLogger.log(`Connected to ${c.guilds.cache.size} guild(s)`);
@@ -213,6 +263,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         })();
         registerInteractionHandler({ discordClient: c, appId: currentAppId });
         registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
+        await reconcileDeletedDiscordChannels(c);
         startExternalOpencodeSessionSync({ discordClient: c });
         await restorePersistedLocalQueues({
             discordClient: c,
@@ -236,18 +287,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.warn(`Background guild channel scan failed: ${error instanceof Error ? error.stack : String(error)}`);
         });
     };
-    // If client is already ready (was logged in before being passed to us),
-    // run setup immediately. Otherwise wait for the ClientReady event.
-    if (discordClient.isReady()) {
-        await setupHandlers(discordClient);
-    }
-    else {
-        discordClient.once(Events.ClientReady, (readyClient) => {
-            void setupHandlers(readyClient).catch((error) => {
-                discordLogger.error(`[GATEWAY] ClientReady handler failed: ${formatErrorWithStack(error)}`);
+    // Keep startup ordered so stale targets are removed before queues and
+    // scheduled tasks can deliver work to them.
+    const setupPromise = discordClient.isReady()
+        ? setupHandlers(discordClient)
+        : new Promise((resolve, reject) => {
+            discordClient.once(Events.ClientReady, (readyClient) => {
+                void setupHandlers(readyClient).then(resolve, reject);
             });
         });
-    }
     discordClient.on(Events.Error, (error) => {
         discordLogger.error('[GATEWAY] Client error:', formatErrorWithStack(error));
     });
@@ -694,7 +742,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     });
                     // 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`);
+                        await sendThreadMessage(thread, asSystemLine(`Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`));
                     }
                 }
                 if (channel.type === ChannelType.GuildText) {
@@ -1150,25 +1198,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     // Dispose runtime when a thread is deleted so memory is freed immediately
     // instead of waiting for the idle sweeper (1 hour default).
     discordClient.on(Events.ThreadDelete, (thread) => {
-        disposeRuntime(thread.id);
+        void cleanupDeletedDiscordThread(thread.id).catch((error) => {
+            notifyError(error instanceof Error ? error : new Error(String(error)), `Failed to clean up deleted thread ${thread.id}`);
+        });
     });
-    // Clean up SQLite when a Discord channel is deleted so project list
-    // doesn't show stale ghost entries. Thread runtimes inside the deleted
-    // channel are disposed by their own ThreadDelete events from Discord.
+    // Clean up SQLite and active child runtimes without relying on Discord to
+    // send separate ThreadDelete events for every child.
     discordClient.on(Events.ChannelDelete, async (channel) => {
         try {
-            // Check if this is the default kimaki channel. If so, preserve the
-            // channel_directories row as a tombstone so we don't recreate it.
-            const mapping = await getChannelDirectory(channel.id);
-            const defaultDir = getDefaultKimakiDirectory();
-            if (mapping && mapping.directory === defaultDir) {
-                discordLogger.log(`Preserving channel_directories row for deleted default channel ${channel.id} as tombstone`);
-                return;
-            }
-            const deleted = await deleteChannelDirectoryById(channel.id);
-            if (deleted) {
-                discordLogger.log(`Cleaned up channel_directories for deleted channel ${channel.id}`);
-            }
+            await cleanupDeletedDiscordChannel(channel.id);
         }
         catch (error) {
             notifyError(error instanceof Error ? error : new Error(String(error)), `Failed to clean up channel_directories for deleted channel ${channel.id}`);
@@ -1180,10 +1218,19 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     if (!discordClient.isReady()) {
         await discordClient.login(token);
     }
+    await setupPromise;
+    // A stop signal during setup: do not start workers against closing resources.
+    if (global.shuttingDown) {
+        return;
+    }
     startHeapMonitor();
     startStdinCpuProfListener();
     const stopTaskRunner = startTaskRunner({ token });
     const stopRuntimeIdleSweeper = startRuntimeIdleSweeper();
+    stopBackgroundWorkers = async () => {
+        await stopRuntimeIdleSweeper();
+        await stopTaskRunner();
+    };
     // Prevent discord.js from permanently killing the REST token on 401.
     // @discordjs/rest calls setToken(null) whenever it receives a 401 response.
     // The gateway proxy now returns 503 for stale-DB rejections (not 401), but
@@ -1198,117 +1245,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         return originalSetToken(newToken);
     };
-    const handleShutdown = async (signal, { skipExit = false } = {}) => {
-        discordLogger.log(`Received ${signal}, cleaning up...`);
-        if (global.shuttingDown) {
-            discordLogger.log('Already shutting down, ignoring duplicate signal');
-            return;
-        }
-        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) => {
-                discordLogger.warn('Failed to flush debounced process callbacks:', error instanceof Error ? error.stack : String(error));
-            });
-            await flushAnalytics();
-            // Cancel pending IPC requests so plugin tools don't hang
-            await cancelAllPendingIpcRequests().catch((e) => {
-                discordLogger.warn('Failed to cancel pending IPC requests:', e.message);
-            });
-            const cleanupPromises = [];
-            for (const [guildId] of voiceConnections) {
-                voiceLogger.log(`[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`);
-                cleanupPromises.push(cleanupVoiceConnection(guildId));
-            }
-            if (cleanupPromises.length > 0) {
-                voiceLogger.log(`[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`);
-                await Promise.allSettled(cleanupPromises);
-                discordLogger.log(`All voice connections cleaned up`);
-            }
-            voiceLogger.log('[SHUTDOWN] Stopping OpenCode server');
-            stopExternalOpencodeSessionSync();
-            await stopOpencodeServer();
-            discordLogger.log('Closing database...');
-            await closeDatabase();
-            discordLogger.log('Stopping hrana server...');
-            await stopHranaServer();
-            discordLogger.log('Destroying Discord client...');
-            // Remove all listeners before destroy to prevent late-arriving shard
-            // errors (from pending DNS lookups, WebSocket frames) from becoming
-            // uncaught exceptions after the client's internal handlers are torn down.
-            discordClient.removeAllListeners();
-            void discordClient.destroy();
-            discordLogger.log('Cleanup complete.');
-            if (!skipExit) {
-                process.exit(0);
-            }
-        }
-        catch (error) {
-            voiceLogger.error('[SHUTDOWN] Error during cleanup:', error);
-            if (!skipExit) {
-                process.exit(1);
-            }
-        }
-    };
-    process.on('SIGTERM', async () => {
-        try {
-            await handleShutdown('SIGTERM');
-        }
-        catch (error) {
-            voiceLogger.error('[SIGTERM] Error during shutdown:', error);
-            process.exit(1);
-        }
-    });
-    process.on('SIGINT', async () => {
-        try {
-            await handleShutdown('SIGINT');
-        }
-        catch (error) {
-            voiceLogger.error('[SIGINT] Error during shutdown:', error);
-            process.exit(1);
-        }
-    });
-    process.on('SIGUSR1', () => {
-        discordLogger.log('Received SIGUSR1, writing heap snapshot...');
-        writeHeapSnapshot().catch((e) => {
-            discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
-        });
-    });
-    // 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) {
-            discordLogger.log(`Self-restart already in progress, ignoring duplicate reason: ${reason}`);
-            return;
-        }
-        selfRestarting = true;
-        discordLogger.log(`Self-restarting (reason: ${reason})...`);
-        setTimeout(() => process.kill(process.pid, 'SIGKILL'), 15_000);
-        try {
-            await handleShutdown(reason, { skipExit: true });
-        }
-        catch (error) {
-            voiceLogger.error(`[${reason}] Error during shutdown:`, error);
-        }
-        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.kill(process.pid, 'SIGKILL');
-    }
-    process.on('SIGUSR2', () => {
-        discordLogger.log('Received SIGUSR2, restarting after cleanup...');
-        void selfRestart('SIGUSR2');
-    });
     process.on('uncaughtException', (error) => {
         // During self-restart or shutdown, discord.js can still fire errors from
         // pending async operations (DNS lookups, WebSocket frames) after the client
@@ -1320,9 +1256,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         discordLogger.error('Uncaught exception:', formatErrorWithStack(error));
         notifyError(error, 'Uncaught exception in bot process');
-        void handleShutdown('uncaughtException', { skipExit: true }).catch((shutdownError) => {
-            discordLogger.error('[uncaughtException] shutdown failed:', formatErrorWithStack(shutdownError));
-        });
+        void shutdownBot('uncaughtException', { skipExit: true });
         setTimeout(() => {
             process.exit(1);
         }, 250).unref();
@@ -1339,3 +1273,137 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         void notifyError(error, 'Unhandled rejection in bot process');
     });
 }
+// ── Process lifecycle ────────────────────────────────────────────────
+// cli-runner installs these handlers right after binding the hrana lock port,
+// long before Discord is ready. Before this, SIGINT/SIGTERM during startup only
+// hit the opencode.ts fallback listener, which does not exit, so the process
+// kept the lock port forever and every next start failed with EADDRINUSE.
+// Every cleanup step below must therefore be safe at any startup phase.
+const SHUTDOWN_DEADLINE_MS = 15_000;
+let activeDiscordClient = null;
+let stopBackgroundWorkers = null;
+let selfRestarting = false;
+let lifecycleHandlersRegistered = false;
+async function shutdownBot(reason, { skipExit = false } = {}) {
+    discordLogger.log(`Received ${reason}, cleaning up...`);
+    if (global.shuttingDown) {
+        discordLogger.log('Already shutting down, ignoring duplicate signal');
+        return;
+    }
+    global.shuttingDown = true;
+    // Cleanup or process.exit() can hang (native worker threads after gateway
+    // failures). Never let a stuck shutdown hold the lock port. Kept ref'd so a
+    // drained event loop cannot exit with code 0 and skip the wrapper restart.
+    setTimeout(() => {
+        process.kill(process.pid, 'SIGKILL');
+    }, SHUTDOWN_DEADLINE_MS);
+    try {
+        stopStdinCpuProfListener();
+        const flushed = await flushCpuProfiling();
+        if (flushed instanceof Error) {
+            discordLogger.warn('Failed to flush CPU profile on shutdown:', flushed.message);
+        }
+        await stopBackgroundWorkers?.();
+        await flushDebouncedProcessCallbacks().catch((error) => {
+            discordLogger.warn('Failed to flush debounced process callbacks:', error instanceof Error ? error.stack : String(error));
+        });
+        await flushAnalytics();
+        // Cancel pending IPC requests so plugin tools don't hang
+        await cancelAllPendingIpcRequests().catch((e) => {
+            discordLogger.warn('Failed to cancel pending IPC requests:', e.message);
+        });
+        const cleanupPromises = [];
+        for (const [guildId] of voiceConnections) {
+            voiceLogger.log(`[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`);
+            cleanupPromises.push(cleanupVoiceConnection(guildId));
+        }
+        if (cleanupPromises.length > 0) {
+            voiceLogger.log(`[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`);
+            await Promise.allSettled(cleanupPromises);
+            discordLogger.log(`All voice connections cleaned up`);
+        }
+        voiceLogger.log('[SHUTDOWN] Stopping OpenCode server');
+        stopExternalOpencodeSessionSync();
+        await stopOpencodeServer();
+        discordLogger.log('Closing database...');
+        await closeDatabase();
+        discordLogger.log('Stopping hrana server...');
+        await stopHranaServer();
+        if (activeDiscordClient) {
+            discordLogger.log('Destroying Discord client...');
+            // Remove all listeners before destroy to prevent late-arriving shard
+            // errors (from pending DNS lookups, WebSocket frames) from becoming
+            // uncaught exceptions after the client's internal handlers are torn down.
+            activeDiscordClient.removeAllListeners();
+            void activeDiscordClient.destroy();
+        }
+        discordLogger.log('Cleanup complete.');
+        if (!skipExit) {
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        voiceLogger.error('[SHUTDOWN] Error during cleanup:', error);
+        if (!skipExit) {
+            process.exit(1);
+        }
+    }
+}
+// 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.
+async function selfRestart(reason) {
+    if (selfRestarting) {
+        discordLogger.log(`Self-restart already in progress, ignoring duplicate reason: ${reason}`);
+        return;
+    }
+    selfRestarting = true;
+    discordLogger.log(`Self-restarting (reason: ${reason})...`);
+    await shutdownBot(reason, { skipExit: true });
+    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.kill(process.pid, 'SIGKILL');
+}
+/** Idempotent. Call as soon as the process owns the lock port. */
+export function registerBotLifecycleHandlers() {
+    if (lifecycleHandlersRegistered) {
+        return;
+    }
+    lifecycleHandlersRegistered = true;
+    // SIGHUP: closing the terminal must stop the bot, not leave it orphaned.
+    for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+        process.on(signal, () => {
+            void shutdownBot(signal);
+        });
+    }
+    process.on('SIGUSR1', () => {
+        discordLogger.log('Received SIGUSR1, writing heap snapshot...');
+        writeHeapSnapshot().catch((e) => {
+            discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
+        });
+    });
+    process.on('SIGUSR2', () => {
+        discordLogger.log('Received SIGUSR2, restarting after cleanup...');
+        void selfRestart('SIGUSR2');
+    });
+    // bin.ts spawns us with an IPC channel. The OS closes it when the wrapper
+    // dies for any reason (including SIGKILL), so an orphaned child exits instead
+    // of holding the lock port. Guarded by __KIMAKI_CHILD so vitest workers,
+    // which also have an IPC channel, are not affected.
+    if (!process.env.__KIMAKI_CHILD) {
+        return;
+    }
+    // The wrapper can die before we get here (e.g. during the eviction wait);
+    // 'disconnect' is not replayed for late listeners.
+    if (!process.connected) {
+        void shutdownBot('wrapper-disconnect');
+        return;
+    }
+    process.on('disconnect', () => {
+        void shutdownBot('wrapper-disconnect');
+    });
+    process.channel?.unref();
+}

package/dist/external-directory-permissions.e2e.test.js

@@ -64,13 +64,13 @@ describe('external directory permissions', () => {
       "--- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER first
       --- from: assistant (TestBot)
-      > *using deterministic-provider/deterministic-v2*
+      -# *using deterministic-provider/deterministic-v2*
       > reading external directory
 
       ┣ read *probe.txt*
 
       > external-directory-probe-done
-      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
@@ -79,7 +79,7 @@ describe('external directory permissions', () => {
       ┣ read *probe.txt*
 
       > external-directory-probe-done
-      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
     `);
         expect(text).not.toContain('Permission Required');
     });

package/dist/external-directory-project-deny.e2e.test.js

@@ -54,7 +54,7 @@ describe('external directory project deny', () => {
       "--- from: user (external-directory-deny-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER denied
       --- from: assistant (TestBot)
-      > *using deterministic-provider/deterministic-v2*
+      -# *using deterministic-provider/deterministic-v2*
       > reading external directory
 
       ┣ read *probe.txt*

package/dist/forum-sync/watchers.js

@@ -251,6 +251,21 @@ export async function stopConfiguredForumSync() {
         });
     }));
 }
+export async function stopForumSyncForChannel(forumChannelId) {
+    const runtimeState = forumStateById.get(forumChannelId);
+    if (runtimeState?.discordDebounceTimer) {
+        clearTimeout(runtimeState.discordDebounceTimer);
+    }
+    if (runtimeState?.fileDebounceTimer) {
+        clearTimeout(runtimeState.fileDebounceTimer);
+    }
+    forumStateById.delete(forumChannelId);
+    const unsubscribe = watcherUnsubscribeByForumId.get(forumChannelId);
+    watcherUnsubscribeByForumId.delete(forumChannelId);
+    await unsubscribe?.().catch((cause) => {
+        forumLogger.warn(`Failed to unsubscribe deleted forum ${forumChannelId}:`, cause);
+    });
+}
 export async function startConfiguredForumSync({ discordClient, appId, }) {
     const loadedConfig = await readForumSyncConfig({ appId });
     if (loadedConfig instanceof Error)