kimaki 0.4.82 → 0.4.84

package/dist/commands/screenshare.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js';
+describe('screenshare security defaults', () => {
+    test('generates a 128-bit tunnel id', () => {
+        const ids = new Set(Array.from({ length: 32 }, () => {
+            return createScreenshareTunnelId();
+        }));
+        expect(ids.size).toBe(32);
+        for (const id of ids) {
+            expect(id).toMatch(/^[0-9a-f]{32}$/);
+        }
+    });
+    test('builds a secure noVNC URL', () => {
+        const url = new URL(buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }));
+        expect(url.origin).toBe('https://novnc.com');
+        expect(url.searchParams.get('host')).toBe('0123456789abcdef-tunnel.kimaki.xyz');
+        expect(url.searchParams.get('port')).toBe('443');
+        expect(url.searchParams.get('encrypt')).toBe('1');
+    });
+});

package/dist/commands/session.js

@@ -10,7 +10,7 @@ import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.SESSION);
 export async function handleSessionCommand({ command, appId, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const prompt = command.options.getString('prompt', true);
     const filesString = command.options.getString('files') || '';
     const agent = command.options.getString('agent') || undefined;

package/dist/commands/undo-redo.js

@@ -5,6 +5,19 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.UNDO_REDO);
+async function waitForSessionIdle({ client, sessionId, directory, timeoutMs = 2_000, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const statusResponse = await client.session.status({ directory });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (!sessionStatus || sessionStatus.type === 'idle') {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+}
 export async function handleUndoCommand({ command, }) {
     const channel = command.channel;
     if (!channel) {
@@ -36,7 +49,7 @@ export async function handleUndoCommand({ command, }) {
         });
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
         await command.reply({
@@ -56,13 +69,36 @@ export async function handleUndoCommand({ command, }) {
         // Fetch session to check existing revert state
         const sessionResponse = await client.session.get({
             sessionID: sessionId,
+            directory: workingDirectory,
         });
         if (sessionResponse.error) {
             await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`);
             return;
         }
+        // Abort if session is busy before reverting, matching TUI behavior
+        // (use-session-commands.tsx always aborts non-idle sessions before revert).
+        // session.status() returns a sparse map — only non-idle sessions have entries,
+        // so a missing key means idle.
+        const statusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (sessionStatus && sessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[UNDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
         const messagesResponse = await client.session.messages({
             sessionID: sessionId,
+            directory: workingDirectory,
         });
         if (messagesResponse.error) {
             await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`);
@@ -87,24 +123,46 @@ export async function handleUndoCommand({ command, }) {
             await command.editReply('No messages to undo');
             return;
         }
+        const targetAssistantMessage = [...messagesResponse.data].reverse().find((m) => {
+            return m.info.role === 'assistant' && m.info.parentID === targetUserMessage.info.id;
+        });
+        const revertMessageId = targetAssistantMessage?.info.id || targetUserMessage.info.id;
         // session.revert() reverts filesystem patches (file edits, writes) and
         // marks the session with revert.messageID. Messages are NOT deleted — they
         // get cleaned up automatically on the next promptAsync() call via
         // SessionRevert.cleanup(). The model only sees messages before the revert
         // point when processing the next prompt.
-        const response = await client.session.revert({
+        logger.log(`[UNDO] session.revert start messageId=${revertMessageId}`);
+        let response = await client.session.revert({
             sessionID: sessionId,
-            messageID: targetUserMessage.info.id,
+            directory: workingDirectory,
+            messageID: revertMessageId,
         });
+        logger.log(`[UNDO] session.revert done error=${Boolean(response.error)}`);
         if (response.error) {
-            await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
-            return;
+            logger.log('[UNDO] retry wait idle before revert retry');
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+            logger.log('[UNDO] retry revert start');
+            response = await client.session.revert({
+                sessionID: sessionId,
+                directory: workingDirectory,
+                messageID: revertMessageId,
+            });
+            logger.log(`[UNDO] retry revert done error=${Boolean(response.error)}`);
+            if (response.error) {
+                await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+                return;
+            }
         }
         const diffInfo = response.data?.revert?.diff
             ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
             : '';
         await command.editReply(`Undone - reverted last assistant message${diffInfo}`);
-        logger.log(`Session ${sessionId} reverted to before user message ${targetUserMessage.info.id}`);
+        logger.log(`Session ${sessionId} reverted at message ${revertMessageId}`);
     }
     catch (error) {
         logger.error('[UNDO] Error:', error);
@@ -142,7 +200,7 @@ export async function handleRedoCommand({ command, }) {
         });
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
         await command.reply({
@@ -162,6 +220,7 @@ export async function handleRedoCommand({ command, }) {
         // Fetch session to check existing revert state
         const sessionResponse = await client.session.get({
             sessionID: sessionId,
+            directory: workingDirectory,
         });
         if (sessionResponse.error) {
             await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`);
@@ -172,12 +231,35 @@ export async function handleRedoCommand({ command, }) {
             await command.editReply('Nothing to redo - no previous undo found');
             return;
         }
+        // Abort if session is busy before reverting/unreverting — both enforce
+        // assertNotBusy in OpenCode and would fail with "Session is busy"
+        const redoStatusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const redoSessionStatus = redoStatusResponse.data?.[sessionId];
+        if (redoSessionStatus && redoSessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[REDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
         // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
         // find the next user message after the current revert point. If one exists,
         // move the revert cursor forward to it (one step redo). If none exists,
         // fully unrevert — we're at the end of the message history.
         const messagesResponse = await client.session.messages({
             sessionID: sessionId,
+            directory: workingDirectory,
         });
         if (messagesResponse.error) {
             await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`);
@@ -193,6 +275,7 @@ export async function handleRedoCommand({ command, }) {
             // No more messages after revert point — fully unrevert
             const response = await client.session.unrevert({
                 sessionID: sessionId,
+                directory: workingDirectory,
             });
             if (response.error) {
                 await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
@@ -205,6 +288,7 @@ export async function handleRedoCommand({ command, }) {
         // Move revert cursor forward one step to the next user message
         const response = await client.session.revert({
             sessionID: sessionId,
+            directory: workingDirectory,
             messageID: nextMessage.info.id,
         });
         if (response.error) {

package/dist/commands/user-command.js

@@ -75,7 +75,7 @@ export const handleUserCommand = async ({ command, appId, }) => {
         });
         return;
     }
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     try {
         // Use the dedicated session.command API instead of formatting as text prompt
         const commandPayload = { name: commandName, arguments: args };

package/dist/config.js

@@ -42,11 +42,26 @@ export function setDataDir(dir) {
 }
 /**
  * Get the projects directory path (for /create-new-project command).
- * Returns <dataDir>/projects
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
  */
 export function getProjectsDir() {
+    const custom = store.getState().projectsDir;
+    if (custom) {
+        return custom;
+    }
     return path.join(getDataDir(), 'projects');
 }
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ projectsDir: resolvedDir });
+}
 const DEFAULT_LOCK_PORT = 29988;
 /**
  * Derive a lock port from the data directory path.

package/dist/database.js

@@ -662,12 +662,34 @@ export async function getThreadSession(threadId) {
  * Set the session ID for a thread.
  */
 export async function setThreadSession(threadId, sessionId) {
+    await upsertThreadSession({
+        threadId,
+        sessionId,
+        source: 'kimaki',
+    });
+}
+export async function upsertThreadSession({ threadId, sessionId, source, }) {
     const prisma = await getPrisma();
     await prisma.thread_sessions.upsert({
         where: { thread_id: threadId },
-        create: { thread_id: threadId, session_id: sessionId },
-        update: { session_id: sessionId },
+        create: {
+            thread_id: threadId,
+            session_id: sessionId,
+            source,
+        },
+        update: {
+            session_id: sessionId,
+            source,
+        },
+    });
+}
+export async function getThreadSessionSource(threadId) {
+    const prisma = await getPrisma();
+    const row = await prisma.thread_sessions.findUnique({
+        where: { thread_id: threadId },
+        select: { source: true },
     });
+    return row?.source;
 }
 /**
  * Get the thread ID for a session.
@@ -1094,6 +1116,14 @@ export async function getAllTextChannelDirectories() {
     });
     return rows.map((row) => row.directory);
 }
+export async function listTrackedTextChannels() {
+    const prisma = await getPrisma();
+    return prisma.channel_directories.findMany({
+        where: { channel_type: 'text' },
+        orderBy: [{ created_at: 'asc' }, { channel_id: 'asc' }],
+        select: { channel_id: true, directory: true, created_at: true },
+    });
+}
 /**
  * Delete all channel directories for a specific directory.
  */
@@ -1103,6 +1133,27 @@ export async function deleteChannelDirectoriesByDirectory(directory) {
         where: { directory },
     });
 }
+/**
+ * Delete a single channel_directories row and all its child rows
+ * (channel_models, channel_agents, channel_worktrees, channel_verbosity,
+ * channel_mention_mode) in a single transaction. scheduled_tasks has
+ * onDelete:SetNull so Prisma handles it automatically.
+ */
+export async function deleteChannelDirectoryById(channelId) {
+    const prisma = await getPrisma();
+    const deletedCount = await prisma.$transaction(async (tx) => {
+        await tx.channel_models.deleteMany({ where: { channel_id: channelId } });
+        await tx.channel_agents.deleteMany({ where: { channel_id: channelId } });
+        await tx.channel_worktrees.deleteMany({ where: { channel_id: channelId } });
+        await tx.channel_verbosity.deleteMany({ where: { channel_id: channelId } });
+        await tx.channel_mention_mode.deleteMany({ where: { channel_id: channelId } });
+        const result = await tx.channel_directories.deleteMany({
+            where: { channel_id: channelId },
+        });
+        return result.count;
+    });
+    return deletedCount > 0;
+}
 /**
  * Get the directory for a voice channel.
  */

package/dist/db.js

@@ -159,6 +159,12 @@ async function migrateSchema(prisma) {
             // Column already exists
         }
     }
+    try {
+        await prisma.$executeRawUnsafe("ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'");
+    }
+    catch {
+        // Column already exists
+    }
     // Migration: move session_thinking data into session_models.variant.
     // session_thinking table is left in place (not dropped) so older kimaki versions
     // that still reference it won't crash on the same database.

package/dist/discord-bot.js

@@ -1,13 +1,12 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, deleteChannelDirectoryById, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
-import { formatWorktreeName } from './commands/new-worktree.js';
+import { formatWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
-import { createWorktreeWithSubmodules } from './worktrees.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
-import { getOpencodeSystemMessage, } from './system-message.js';
+import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import yaml from 'js-yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
 import { isVoiceAttachment } from './voice-attachment.js';
@@ -28,6 +27,7 @@ import { markDiscordGatewayReady, stopHranaServer } from './hrana-server.js';
 import { notifyError } from './sentry.js';
 import { flushDebouncedProcessCallbacks } from './debounced-process-flush.js';
 import { startRuntimeIdleSweeper } from './runtime-idle-sweeper.js';
+import { startExternalOpencodeSessionSync, stopExternalOpencodeSessionSync, } from './external-opencode-sync.js';
 export { initDatabase, closeDatabase, getChannelDirectory, getPrisma, } from './database.js';
 export { initializeOpencodeForDirectory } from './opencode.js';
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, } from './discord-utils.js';
@@ -162,6 +162,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         markDiscordGatewayReady();
         registerInteractionHandler({ discordClient: c, appId: currentAppId });
         registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
+        startExternalOpencodeSessionSync({ discordClient: c });
         // Channel logging is informational only; do it in background so startup stays responsive.
         void (async () => {
             for (const guild of c.guilds.cache.values()) {
@@ -244,7 +245,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const promptMarker = parseEmbedFooterMarker({
                 footer: message.embeds[0]?.footer?.text,
             });
-            const isCliInjectedPrompt = Boolean(isSelfBotMessage && promptMarker?.cliThreadPrompt);
+            const isCliInjectedPrompt = Boolean(isSelfBotMessage && isInjectedPromptMarker({ marker: promptMarker }));
             const sessionStartSource = isCliInjectedPrompt
                 ? parseSessionStartSourceFromMarker(promptMarker)
                 : undefined;
@@ -419,7 +420,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     discordLogger.log(`Cannot process message: no project directory for thread ${thread.id}`);
                     return;
                 }
-                // Capture narrowed non-undefined value for use in the preprocess closure
                 const resolvedProjectDir = projectDirectory;
                 const sdkDir = worktreeInfo?.status === 'ready' &&
                     worktreeInfo.worktree_directory
@@ -442,7 +442,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     cancelHtmlActionsForThread(thread.id);
                     const dismissedPermission = await cancelPendingPermission(thread.id);
                     if (dismissedPermission) {
-                        runtime.abortActiveRun('user sent a new message while permission was pending');
+                        await runtime.abortActiveRunAndWait({
+                            reason: 'user sent a new message while permission was pending',
+                        });
                     }
                     const questionResult = await cancelPendingQuestion(thread.id, message.content);
                     void cancelPendingFileUpload(thread.id);
@@ -460,6 +462,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     username: cliInjectedUsername ||
                         message.member?.displayName ||
                         message.author.displayName,
+                    sourceMessageId: message.id,
+                    sourceThreadId: thread.id,
                     appId: currentAppId,
                     agent: cliInjectedAgent,
                     model: cliInjectedModel,
@@ -560,42 +564,21 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 if (shouldUseWorktrees) {
                     const worktreeName = formatWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
                     discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
-                    // Store pending worktree immediately so bot knows about it
-                    await createPendingWorktree({
-                        threadId: thread.id,
+                    const worktreeStatusMessage = await thread
+                        .send({
+                        content: worktreeCreatingMessage(worktreeName),
+                        flags: SILENT_MESSAGE_FLAGS,
+                    })
+                        .catch(() => undefined);
+                    const result = await createWorktreeInBackground({
+                        thread,
+                        starterMessage: worktreeStatusMessage,
                         worktreeName,
                         projectDirectory,
+                        rest: discordClient.rest,
                     });
-                    const worktreeResult = await createWorktreeWithSubmodules({
-                        directory: projectDirectory,
-                        name: worktreeName,
-                    });
-                    if (worktreeResult instanceof Error) {
-                        const errMsg = worktreeResult.message;
-                        discordLogger.error(`[WORKTREE] Creation failed: ${errMsg}`);
-                        await setWorktreeError({
-                            threadId: thread.id,
-                            errorMessage: errMsg,
-                        });
-                        await thread.send({
-                            content: `⚠️ Failed to create worktree: ${errMsg}\nUsing main project directory instead.`,
-                            flags: NOTIFY_MESSAGE_FLAGS,
-                        });
-                    }
-                    else {
-                        await setWorktreeReady({
-                            threadId: thread.id,
-                            worktreeDirectory: worktreeResult.directory,
-                        });
-                        sessionDirectory = worktreeResult.directory;
-                        discordLogger.log(`[WORKTREE] Created: ${worktreeResult.directory} (branch: ${worktreeResult.branch})`);
-                        // React with tree emoji to mark as worktree thread
-                        await reactToThread({
-                            rest: discordClient.rest,
-                            threadId: thread.id,
-                            channelId: thread.parentId || undefined,
-                            emoji: '🌳',
-                        });
+                    if (!(result instanceof Error)) {
+                        sessionDirectory = result;
                     }
                 }
                 const channelRuntime = getOrCreateRuntime({
@@ -610,6 +593,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     prompt: '',
                     userId: message.author.id,
                     username: message.member?.displayName || message.author.displayName,
+                    sourceMessageId: message.id,
+                    sourceThreadId: thread.id,
                     appId: currentAppId,
                     preprocess: () => {
                         return preprocessNewThreadMessage({
@@ -711,58 +696,21 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 discordLogger.log(`[BOT_SESSION] Creating worktree: ${marker.worktree}`);
                 const worktreeStatusMessage = await thread
                     .send({
-                    content: `🌳 Creating worktree: ${marker.worktree}\n⏳ Setting up (this can take a bit)...`,
+                    content: worktreeCreatingMessage(marker.worktree),
                     flags: SILENT_MESSAGE_FLAGS,
                 })
-                    .catch(() => {
-                    return null;
-                });
-                await createPendingWorktree({
-                    threadId: thread.id,
+                    .catch(() => undefined);
+                const result = await createWorktreeInBackground({
+                    thread,
+                    starterMessage: worktreeStatusMessage,
                     worktreeName: marker.worktree,
                     projectDirectory,
+                    rest: discordClient.rest,
                 });
-                const worktreeResult = await createWorktreeWithSubmodules({
-                    directory: projectDirectory,
-                    name: marker.worktree,
-                });
-                if (errore.isError(worktreeResult)) {
-                    discordLogger.error(`[BOT_SESSION] Worktree creation failed: ${worktreeResult.message}`);
-                    await setWorktreeError({
-                        threadId: thread.id,
-                        errorMessage: worktreeResult.message,
-                    });
-                    await (worktreeStatusMessage?.edit({
-                        content: `⚠️ Failed to create worktree: ${worktreeResult.message}\nUsing main project directory instead.`,
-                        flags: NOTIFY_MESSAGE_FLAGS,
-                    }) ||
-                        thread.send({
-                            content: `⚠️ Failed to create worktree: ${worktreeResult.message}\nUsing main project directory instead.`,
-                            flags: NOTIFY_MESSAGE_FLAGS,
-                        }));
+                if (result instanceof Error) {
                     return projectDirectory;
                 }
-                await setWorktreeReady({
-                    threadId: thread.id,
-                    worktreeDirectory: worktreeResult.directory,
-                });
-                discordLogger.log(`[BOT_SESSION] Worktree created: ${worktreeResult.directory}`);
-                // React with tree emoji to mark as worktree thread
-                await reactToThread({
-                    rest: discordClient.rest,
-                    threadId: thread.id,
-                    channelId: thread.parentId || undefined,
-                    emoji: '🌳',
-                });
-                await (worktreeStatusMessage?.edit({
-                    content: `🌳 **Worktree ready: ${marker.worktree}**\n📁 \`${worktreeResult.directory}\`\n🌿 Branch: \`${worktreeResult.branch}\``,
-                    flags: SILENT_MESSAGE_FLAGS,
-                }) ||
-                    thread.send({
-                        content: `🌳 **Worktree ready: ${marker.worktree}**\n📁 \`${worktreeResult.directory}\`\n🌿 Branch: \`${worktreeResult.branch}\``,
-                        flags: SILENT_MESSAGE_FLAGS,
-                    }));
-                return worktreeResult.directory;
+                return result;
             })();
             discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
             const botThreadStartSource = parseSessionStartSourceFromMarker(marker);
@@ -811,6 +759,20 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     discordClient.on(Events.ThreadDelete, (thread) => {
         disposeRuntime(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.
+    discordClient.on(Events.ChannelDelete, async (channel) => {
+        try {
+            const deleted = await deleteChannelDirectoryById(channel.id);
+            if (deleted) {
+                discordLogger.log(`Cleaned up channel_directories for deleted channel ${channel.id}`);
+            }
+        }
+        catch (error) {
+            notifyError(error instanceof Error ? error : new Error(String(error)), `Failed to clean up channel_directories for deleted channel ${channel.id}`);
+        }
+    });
     // Skip login if the caller already connected the client (e.g. cli.ts logs in
     // before calling startDiscordBot). Calling login() again destroys the existing
     // WebSocket (close code 1000) and triggers a spurious ShardReconnecting event.
@@ -849,6 +811,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 discordLogger.log(`All voice connections cleaned up`);
             }
             voiceLogger.log('[SHUTDOWN] Stopping OpenCode server');
+            stopExternalOpencodeSessionSync();
             await stopOpencodeServer();
             discordLogger.log('Closing database...');
             await closeDatabase();

package/dist/discord-command-registration.js

@@ -360,7 +360,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('screenshare')
-            .setDescription(truncateCommandDescription('Start screen sharing via VNC tunnel (auto-stops after 1 hour)'))
+            .setDescription(truncateCommandDescription('Start screen sharing via VNC tunnel (auto-stops after 30 minutes)'))
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()