kimaki 0.4.43 → 0.4.45

package/dist/channel-management.js

@@ -3,8 +3,7 @@
 // extracts channel metadata from topic tags, and ensures category structure.
 import { ChannelType } from 'discord.js';
 import path from 'node:path';
-import { getDatabase } from './database.js';
-import { extractTagsArrays } from './xml.js';
+import { getDatabase, getChannelDirectory } from './database.js';
 export async function ensureKimakiCategory(guild, botName) {
     // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
     const isKimakiBot = botName?.toLowerCase() === 'kimaki';
@@ -53,7 +52,7 @@ export async function createProjectChannels({ guild, projectDirectory, appId, bo
         name: channelName,
         type: ChannelType.GuildText,
         parent: kimakiCategory,
-        topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+        // Channel configuration is stored in SQLite, not in the topic
     });
     const voiceChannel = await guild.channels.create({
         name: channelName,
@@ -79,22 +78,14 @@ export async function getChannelsWithDescriptions(guild) {
         .forEach((channel) => {
         const textChannel = channel;
         const description = textChannel.topic || null;
-        let kimakiDirectory;
-        let kimakiApp;
-        if (description) {
-            const extracted = extractTagsArrays({
-                xml: description,
-                tags: ['kimaki.directory', 'kimaki.app'],
-            });
-            kimakiDirectory = extracted['kimaki.directory']?.[0]?.trim();
-            kimakiApp = extracted['kimaki.app']?.[0]?.trim();
-        }
+        // Get channel config from database instead of parsing XML from topic
+        const channelConfig = getChannelDirectory(textChannel.id);
         channels.push({
             id: textChannel.id,
             name: textChannel.name,
             description,
-            kimakiDirectory,
-            kimakiApp,
+            kimakiDirectory: channelConfig?.directory,
+            kimakiApp: channelConfig?.appId || undefined,
         });
     });
     return channels;

package/dist/cli.js

@@ -5,7 +5,7 @@
 import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, abbreviatePath } from './utils.js';
-import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
+import { getChannelsWithDescriptions, createDiscordClient, getDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
@@ -15,7 +15,6 @@ import { uploadFilesToDiscord } from './discord-utils.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
 import { setDataDir, getDataDir, getLockPort } from './config.js';
-import { extractTagsArrays } from './xml.js';
 import { sanitizeAgentName } from './commands/agent.js';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
@@ -161,15 +160,27 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-worktree')
-            .setDescription('Create a new git worktree and start a session thread')
+            .setDescription('Create a new git worktree (in thread: uses thread name if no name given)')
             .addStringOption((option) => {
             option
                 .setName('name')
-                .setDescription('Name for the worktree (will be formatted: lowercase, spaces to dashes)')
-                .setRequired(true);
+                .setDescription('Name for worktree (optional in threads - uses thread name)')
+                .setRequired(false);
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('merge-worktree')
+            .setDescription('Merge the worktree branch into the default branch')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('enable-worktrees')
+            .setDescription('Enable automatic git worktree creation for new sessions in this channel')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('disable-worktrees')
+            .setDescription('Disable automatic git worktree creation for new sessions in this channel')
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription('Create Discord channels for a new OpenCode project')
@@ -246,6 +257,18 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .setName('redo')
             .setDescription('Redo previously undone changes')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('verbosity')
+            .setDescription('Set output verbosity for new sessions in this channel')
+            .addStringOption((option) => {
+            option
+                .setName('level')
+                .setDescription('Verbosity level')
+                .setRequired(true)
+                .addChoices({ name: 'tools-and-text (default)', value: 'tools-and-text' }, { name: 'text-only', value: 'text-only' });
+            return option;
+        })
+            .toJSON(),
     ];
     // Add user-defined commands with -cmd suffix
     for (const cmd of userCommands) {
@@ -365,7 +388,7 @@ async function backgroundInit({ currentDir, token, appId, }) {
         cliLogger.error('Background init failed:', error instanceof Error ? error.message : String(error));
     }
 }
-async function run({ restart, addChannels }) {
+async function run({ restart, addChannels, useWorktrees }) {
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
     // Step 0: Check if OpenCode CLI is available
@@ -600,7 +623,7 @@ async function run({ restart, addChannels }) {
     const isQuickStart = existingBot && !forceSetup && !addChannels;
     if (isQuickStart) {
         s.start('Starting Discord bot...');
-        await startDiscordBot({ token, appId, discordClient });
+        await startDiscordBot({ token, appId, discordClient, useWorktrees });
         s.stop('Discord bot is running!');
         // Background: OpenCode init + slash command registration (non-blocking)
         void backgroundInit({ currentDir, token, appId });
@@ -731,7 +754,7 @@ async function run({ restart, addChannels }) {
         cliLogger.error('Failed to register slash commands:', error instanceof Error ? error.message : String(error));
     });
     s.start('Starting Discord bot...');
-    await startDiscordBot({ token, appId, discordClient });
+    await startDiscordBot({ token, appId, discordClient, useWorktrees });
     s.stop('Discord bot is running!');
     showReadyMessage({ kimakiChannels, createdChannels, appId });
     outro('✨ Setup complete! Listening for new messages... do not close this process.');
@@ -742,6 +765,7 @@ cli
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
     .option('--install-url', 'Print the bot install URL and exit')
+    .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -767,6 +791,7 @@ cli
             restart: options.restart,
             addChannels: options.addChannels,
             dataDir: options.dataDir,
+            useWorktrees: options.useWorktrees,
         });
     }
     catch (error) {
@@ -1007,20 +1032,13 @@ cli
             throw new Error(`Discord API error: ${channelResponse.status} - ${error}`);
         }
         const channelData = (await channelResponse.json());
-        if (!channelData.topic) {
-            s.stop('Channel has no topic');
-            throw new Error(`Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`);
-        }
-        const extracted = extractTagsArrays({
-            xml: channelData.topic,
-            tags: ['kimaki.directory', 'kimaki.app'],
-        });
-        const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-        const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-        if (!projectDirectory) {
-            s.stop('No kimaki.directory tag found');
-            throw new Error(`Channel #${channelData.name} has no <kimaki.directory> tag in topic.`);
+        const channelConfig = getChannelDirectory(channelData.id);
+        if (!channelConfig) {
+            s.stop('Channel not configured');
+            throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
         }
+        const projectDirectory = channelConfig.directory;
+        const channelAppId = channelConfig.appId || undefined;
         // Verify app ID matches if both are present
         if (channelAppId && appId && channelAppId !== appId) {
             s.stop('Channel belongs to different bot');
@@ -1031,6 +1049,12 @@ cli
         // If prompt exceeds this, send it as a file attachment instead.
         const DISCORD_MAX_LENGTH = 2000;
         let starterMessage;
+        // Embed marker for auto-start sessions (unless --notify-only)
+        // Bot checks for this embed footer to know it should start a session
+        const AUTO_START_MARKER = 'kimaki:start';
+        const autoStartEmbed = notifyOnly
+            ? undefined
+            : [{ color: 0x2b2d31, footer: { text: AUTO_START_MARKER } }];
         if (prompt.length > DISCORD_MAX_LENGTH) {
             // Send as file attachment with a short summary
             const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
@@ -1048,6 +1072,7 @@ cli
                 formData.append('payload_json', JSON.stringify({
                     content: summaryContent,
                     attachments: [{ id: 0, filename: 'prompt.md' }],
+                    embeds: autoStartEmbed,
                 }));
                 const buffer = fs.readFileSync(tmpFile);
                 formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
@@ -1080,6 +1105,7 @@ cli
                 },
                 body: JSON.stringify({
                     content: prompt,
+                    embeds: autoStartEmbed,
                 }),
             });
             if (!starterMessageResponse.ok) {
@@ -1109,17 +1135,6 @@ cli
             throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
         }
         const threadData = (await threadResponse.json());
-        // Mark thread for auto-start if not notify-only
-        // This is optional - only works if local database exists (for local bot auto-start)
-        if (!notifyOnly) {
-            try {
-                const db = getDatabase();
-                db.prepare('INSERT OR REPLACE INTO pending_auto_start (thread_id) VALUES (?)').run(threadData.id);
-            }
-            catch {
-                // Database not available (e.g., CI environment) - skip auto-start marking
-            }
-        }
         s.stop('Thread created!');
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
         const successMessage = notifyOnly
@@ -1134,5 +1149,168 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('add-project [directory]', 'Create Discord channels for a project directory')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
+    .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
+    .action(async (directory, options) => {
+    try {
+        const absolutePath = path.resolve(directory || '.');
+        if (!fs.existsSync(absolutePath)) {
+            cliLogger.error(`Directory does not exist: ${absolutePath}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Get bot token from env var or database
+        const envToken = process.env.KIMAKI_BOT_TOKEN;
+        let botToken;
+        let appId = options.appId;
+        if (envToken) {
+            botToken = envToken;
+            if (!appId) {
+                try {
+                    const db = getDatabase();
+                    const botRow = db
+                        .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                        .get();
+                    appId = botRow?.app_id;
+                }
+                catch {
+                    // Database might not exist in CI
+                }
+            }
+        }
+        else {
+            try {
+                const db = getDatabase();
+                const botRow = db
+                    .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                    .get();
+                if (botRow) {
+                    botToken = botRow.token;
+                    appId = appId || botRow.app_id;
+                }
+            }
+            catch (e) {
+                cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
+            }
+        }
+        if (!botToken) {
+            cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!appId) {
+            cliLogger.error('App ID is required to create channels. Use --app-id or run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start('Connecting to Discord...');
+        const client = await createDiscordClient();
+        await new Promise((resolve, reject) => {
+            client.once(Events.ClientReady, () => {
+                resolve();
+            });
+            client.once(Events.Error, reject);
+            client.login(botToken);
+        });
+        s.message('Finding guild...');
+        // Find guild
+        let guild;
+        if (options.guild) {
+            // Get raw guild ID from argv to avoid cac's number coercion losing precision on large IDs
+            const guildArgIndex = process.argv.findIndex((arg) => arg === '-g' || arg === '--guild');
+            const rawGuildArg = guildArgIndex >= 0 ? process.argv[guildArgIndex + 1] : undefined;
+            const guildId = rawGuildArg || String(options.guild);
+            const foundGuild = client.guilds.cache.get(guildId);
+            if (!foundGuild) {
+                s.stop('Guild not found');
+                cliLogger.error(`Guild not found: ${guildId}`);
+                client.destroy();
+                process.exit(EXIT_NO_RESTART);
+            }
+            guild = foundGuild;
+        }
+        else {
+            // Auto-detect: prefer guild with existing channels for this bot, else first guild
+            const db = getDatabase();
+            const existingChannelRow = db
+                .prepare('SELECT channel_id FROM channel_directories WHERE app_id = ? ORDER BY created_at DESC LIMIT 1')
+                .get(appId);
+            if (existingChannelRow) {
+                try {
+                    const ch = await client.channels.fetch(existingChannelRow.channel_id);
+                    if (ch && 'guild' in ch && ch.guild) {
+                        guild = ch.guild;
+                    }
+                    else {
+                        throw new Error('Channel has no guild');
+                    }
+                }
+                catch {
+                    // Channel might be deleted, fall back to first guild
+                    const firstGuild = client.guilds.cache.first();
+                    if (!firstGuild) {
+                        s.stop('No guild found');
+                        cliLogger.error('No guild found. Add the bot to a server first.');
+                        client.destroy();
+                        process.exit(EXIT_NO_RESTART);
+                    }
+                    guild = firstGuild;
+                }
+            }
+            else {
+                const firstGuild = client.guilds.cache.first();
+                if (!firstGuild) {
+                    s.stop('No guild found');
+                    cliLogger.error('No guild found. Add the bot to a server first.');
+                    client.destroy();
+                    process.exit(EXIT_NO_RESTART);
+                }
+                guild = firstGuild;
+            }
+        }
+        // Check if channel already exists in this guild
+        s.message('Checking for existing channel...');
+        try {
+            const db = getDatabase();
+            const existingChannels = db
+                .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?')
+                .all(absolutePath, 'text', appId);
+            for (const existingChannel of existingChannels) {
+                try {
+                    const ch = await client.channels.fetch(existingChannel.channel_id);
+                    if (ch && 'guild' in ch && ch.guild?.id === guild.id) {
+                        s.stop('Channel already exists');
+                        note(`Channel already exists for this directory in ${guild.name}.\n\nChannel: <#${existingChannel.channel_id}>\nDirectory: ${absolutePath}`, '⚠️  Already Exists');
+                        client.destroy();
+                        process.exit(0);
+                    }
+                }
+                catch {
+                    // Channel might be deleted, continue checking
+                }
+            }
+        }
+        catch {
+            // Database might not exist, continue to create
+        }
+        s.message(`Creating channels in ${guild.name}...`);
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: absolutePath,
+            appId,
+            botName: client.user?.username,
+        });
+        client.destroy();
+        s.stop('Channels created!');
+        const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
+        note(`Created channels for project:\n\n📝 Text: #${channelName}\n🔊 Voice: #${channelName}\n📁 Directory: ${absolutePath}\n\nURL: ${channelUrl}`, '✅ Success');
+        console.log(channelUrl);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli.help();
 cli.parse();

package/dist/commands/merge-worktree.js

@@ -0,0 +1,152 @@
+// /merge-worktree command - Merge worktree commits into main/default branch.
+// Handles both branch-based worktrees and detached HEAD state.
+// After merge, switches to detached HEAD at main so user can keep working.
+import {} from 'discord.js';
+import { getThreadWorktree } from '../database.js';
+import { createLogger } from '../logger.js';
+import { execAsync } from '../worktree-utils.js';
+const logger = createLogger('MERGE-WORKTREE');
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ ';
+/**
+ * Remove the worktree prefix from a thread title.
+ * Uses Promise.race with timeout since Discord thread title updates can hang.
+ */
+async function removeWorktreePrefixFromTitle(thread) {
+    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+        return;
+    }
+    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    // Race between the edit and a timeout - thread title updates are heavily rate-limited
+    const timeoutMs = 5000;
+    const editPromise = thread.setName(newName).catch((e) => {
+        logger.warn(`Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`);
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            logger.warn(`Thread title update timed out after ${timeoutMs}ms`);
+            resolve();
+        }, timeoutMs);
+    });
+    await Promise.race([editPromise, timeoutPromise]);
+}
+/**
+ * Check if worktree is in detached HEAD state.
+ */
+async function isDetachedHead(worktreeDir) {
+    try {
+        await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Get current branch name (returns null if detached).
+ */
+async function getCurrentBranch(worktreeDir) {
+    try {
+        const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleMergeWorktreeCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const channel = command.channel;
+    // Must be in a thread
+    if (!channel || !channel.isThread()) {
+        await command.editReply('This command can only be used in a thread');
+        return;
+    }
+    const thread = channel;
+    // Get worktree info from database
+    const worktreeInfo = getThreadWorktree(thread.id);
+    if (!worktreeInfo) {
+        await command.editReply('This thread is not associated with a worktree');
+        return;
+    }
+    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+        return;
+    }
+    const mainRepoDir = worktreeInfo.project_directory;
+    const worktreeDir = worktreeInfo.worktree_directory;
+    try {
+        // 1. Check for uncommitted changes
+        const { stdout: status } = await execAsync(`git -C "${worktreeDir}" status --porcelain`);
+        if (status.trim()) {
+            await command.editReply(`❌ Uncommitted changes detected in worktree.\n\nPlease commit your changes first, then retry \`/merge-worktree\`.`);
+            return;
+        }
+        // 2. Get the default branch name
+        logger.log(`Getting default branch for ${mainRepoDir}`);
+        let defaultBranch;
+        try {
+            const { stdout } = await execAsync(`git -C "${mainRepoDir}" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`);
+            defaultBranch = stdout.trim() || 'main';
+        }
+        catch {
+            defaultBranch = 'main';
+        }
+        // 3. Determine if we're on a branch or detached HEAD
+        const isDetached = await isDetachedHead(worktreeDir);
+        const currentBranch = await getCurrentBranch(worktreeDir);
+        let branchToMerge;
+        let tempBranch = null;
+        if (isDetached) {
+            // Create a temporary branch from detached HEAD
+            tempBranch = `temp-merge-${Date.now()}`;
+            logger.log(`Detached HEAD detected, creating temp branch: ${tempBranch}`);
+            await execAsync(`git -C "${worktreeDir}" checkout -b ${tempBranch}`);
+            branchToMerge = tempBranch;
+        }
+        else {
+            branchToMerge = currentBranch || worktreeInfo.worktree_name;
+        }
+        logger.log(`Default branch: ${defaultBranch}, branch to merge: ${branchToMerge}`);
+        // 4. Merge default branch INTO worktree (handles diverged branches)
+        logger.log(`Merging ${defaultBranch} into worktree at ${worktreeDir}`);
+        try {
+            await execAsync(`git -C "${worktreeDir}" merge ${defaultBranch} --no-edit`);
+        }
+        catch (e) {
+            // If merge fails (conflicts), abort and report
+            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => { });
+            // Clean up temp branch if we created one
+            if (tempBranch) {
+                await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch(() => { });
+                await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch(() => { });
+            }
+            throw new Error(`Merge conflict - resolve manually in worktree then retry`);
+        }
+        // 5. Update default branch ref to point to current HEAD
+        // Use update-ref instead of fetch because fetch refuses if branch is checked out
+        logger.log(`Updating ${defaultBranch} to point to current HEAD`);
+        const { stdout: commitHash } = await execAsync(`git -C "${worktreeDir}" rev-parse HEAD`);
+        await execAsync(`git -C "${mainRepoDir}" update-ref refs/heads/${defaultBranch} ${commitHash.trim()}`);
+        // 6. Switch to detached HEAD at default branch (allows main to be checked out elsewhere)
+        logger.log(`Switching to detached HEAD at ${defaultBranch}`);
+        await execAsync(`git -C "${worktreeDir}" checkout --detach ${defaultBranch}`);
+        // 7. Delete the merged branch (temp or original)
+        logger.log(`Deleting merged branch ${branchToMerge}`);
+        await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch(() => { });
+        // Also delete the original worktree branch if different from what we merged
+        if (!isDetached && branchToMerge !== worktreeInfo.worktree_name) {
+            await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch(() => { });
+        }
+        // 8. Remove worktree prefix from thread title (fire and forget with timeout)
+        void removeWorktreePrefixFromTitle(thread);
+        const sourceDesc = isDetached ? 'detached commits' : `\`${branchToMerge}\``;
+        await command.editReply(`✅ Merged ${sourceDesc} into \`${defaultBranch}\`\n\nWorktree now at detached HEAD - you can keep working here.`);
+        logger.log(`Successfully merged ${branchToMerge} into ${defaultBranch}`);
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        logger.error(`Merge failed: ${errorMsg}`);
+        await command.editReply(`❌ Merge failed:\n\`\`\`\n${errorMsg}\n\`\`\``);
+    }
+}

package/dist/commands/permissions.js

@@ -17,6 +17,7 @@ export async function showPermissionDropdown({ thread, permission, directory, })
     const contextHash = crypto.randomBytes(8).toString('hex');
     const context = {
         permission,
+        requestIds: [permission.id],
         directory,
         thread,
         contextHash,
@@ -80,10 +81,13 @@ export async function handlePermissionSelectMenu(interaction) {
         if (!clientV2) {
             throw new Error('OpenCode server not found for directory');
         }
-        await clientV2.permission.reply({
-            requestID: context.permission.id,
-            reply: response,
-        });
+        const requestIds = context.requestIds.length > 0 ? context.requestIds : [context.permission.id];
+        await Promise.all(requestIds.map((requestId) => {
+            return clientV2.permission.reply({
+                requestID: requestId,
+                reply: response,
+            });
+        }));
         pendingPermissionContexts.delete(contextHash);
         // Update message: show result and remove dropdown
         const resultText = (() => {
@@ -104,7 +108,7 @@ export async function handlePermissionSelectMenu(interaction) {
                 resultText,
             components: [], // Remove the dropdown
         });
-        logger.log(`Permission ${context.permission.id} ${response}`);
+        logger.log(`Permission ${context.permission.id} ${response} (${requestIds.length} request(s))`);
     }
     catch (error) {
         logger.error('Error handling permission:', error);
@@ -114,6 +118,18 @@ export async function handlePermissionSelectMenu(interaction) {
         });
     }
 }
+export function addPermissionRequestToContext({ contextHash, requestId, }) {
+    const context = pendingPermissionContexts.get(contextHash);
+    if (!context) {
+        return false;
+    }
+    if (context.requestIds.includes(requestId)) {
+        return false;
+    }
+    context.requestIds = [...context.requestIds, requestId];
+    pendingPermissionContexts.set(contextHash, context);
+    return true;
+}
 /**
  * Clean up a pending permission context (e.g., on auto-reject).
  */

package/dist/commands/queue.js

@@ -41,7 +41,11 @@ export async function handleQueueCommand({ command }) {
         return;
     }
     // Check if there's an active request running
-    const hasActiveRequest = abortControllers.has(row.session_id);
+    const existingController = abortControllers.get(row.session_id);
+    const hasActiveRequest = Boolean(existingController && !existingController.signal.aborted);
+    if (existingController && existingController.signal.aborted) {
+        abortControllers.delete(row.session_id);
+    }
     if (!hasActiveRequest) {
         // No active request, send immediately
         const textChannel = await resolveTextChannel(channel);

package/dist/commands/resume.js

@@ -1,10 +1,9 @@
 // /resume command - Resume an existing OpenCode session.
 import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
-import { getDatabase } from '../database.js';
+import { getDatabase, getChannelDirectory } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { extractTagsArrays } from '../xml.js';
+import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger } from '../logger.js';
 import * as errore from 'errore';
@@ -18,16 +17,9 @@ export async function handleResumeCommand({ command, appId }) {
         return;
     }
     const textChannel = channel;
-    let projectDirectory;
-    let channelAppId;
-    if (textChannel.topic) {
-        const extracted = extractTagsArrays({
-            xml: textChannel.topic,
-            tags: ['kimaki.directory', 'kimaki.app'],
-        });
-        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-        channelAppId = extracted['kimaki.app']?.[0]?.trim();
-    }
+    const channelConfig = getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    const channelAppId = channelConfig?.appId || undefined;
     if (channelAppId && channelAppId !== appId) {
         await command.editReply('This channel is not configured for this bot');
         return;
@@ -102,12 +94,12 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
     if (interaction.channel) {
         const textChannel = await resolveTextChannel(interaction.channel);
         if (textChannel) {
-            const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
-            if (channelAppId && channelAppId !== appId) {
+            const channelConfig = getChannelDirectory(textChannel.id);
+            if (channelConfig?.appId && channelConfig.appId !== appId) {
                 await interaction.respond([]);
                 return;
             }
-            projectDirectory = directory;
+            projectDirectory = channelConfig?.directory;
         }
     }
     if (!projectDirectory) {