kimaki 0.4.44 → 0.4.45

package/dist/commands/worktree.js

@@ -3,10 +3,9 @@
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
-import { createPendingWorktree, setWorktreeReady, setWorktreeError, } from '../database.js';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { extractTagsArrays } from '../xml.js';
 import { createLogger } from '../logger.js';
 import { createWorktreeWithSubmodules } from '../worktree-utils.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
@@ -21,6 +20,7 @@ class WorktreeError extends Error {
 /**
  * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
  * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
  */
 export function formatWorktreeName(name) {
     const formatted = name
@@ -28,31 +28,44 @@ export function formatWorktreeName(name) {
         .trim()
         .replace(/\s+/g, '-')
         .replace(/[^a-z0-9-]/g, '');
+    if (!formatted) {
+        return '';
+    }
     return `opencode/kimaki-${formatted}`;
 }
 /**
- * Get project directory from channel topic.
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName) {
+    // Handle existing "⬦ worktree: opencode/kimaki-name" format
+    const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i);
+    const extractedName = worktreeMatch?.[1]?.trim();
+    if (extractedName) {
+        // If already has opencode/kimaki- prefix, return as is
+        if (extractedName.startsWith('opencode/kimaki-')) {
+            return extractedName;
+        }
+        return formatWorktreeName(extractedName);
+    }
+    // Use thread name directly
+    return formatWorktreeName(threadName);
+}
+/**
+ * Get project directory from database.
  */
 function getProjectDirectoryFromChannel(channel, appId) {
-    if (!channel.topic) {
-        return new WorktreeError('This channel has no topic configured');
+    const channelConfig = getChannelDirectory(channel.id);
+    if (!channelConfig) {
+        return new WorktreeError('This channel is not configured with a project directory');
     }
-    const extracted = extractTagsArrays({
-        xml: channel.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-    });
-    const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-    const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-    if (channelAppId && channelAppId !== appId) {
+    if (channelConfig.appId && channelConfig.appId !== appId) {
         return new WorktreeError('This channel is not configured for this bot');
     }
-    if (!projectDirectory) {
-        return new WorktreeError('This channel is not configured with a project directory');
-    }
-    if (!fs.existsSync(projectDirectory)) {
-        return new WorktreeError(`Directory does not exist: ${projectDirectory}`);
+    if (!fs.existsSync(channelConfig.directory)) {
+        return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`);
     }
-    return projectDirectory;
+    return channelConfig.directory;
 }
 /**
  * Create worktree in background and update starter message when done.
@@ -80,15 +93,30 @@ async function createWorktreeInBackground({ thread, starterMessage, worktreeName
 }
 export async function handleNewWorktreeCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
-    const rawName = command.options.getString('name', true);
-    const worktreeName = formatWorktreeName(rawName);
-    if (worktreeName === 'kimaki-') {
-        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+    const channel = command.channel;
+    if (!channel) {
+        await command.editReply('Cannot determine channel');
         return;
     }
-    const channel = command.channel;
-    if (!channel || channel.type !== ChannelType.GuildText) {
-        await command.editReply('This command can only be used in text channels');
+    const isThread = channel.type === ChannelType.PublicThread || channel.type === ChannelType.PrivateThread;
+    // Handle command in existing thread - attach worktree to this thread
+    if (isThread) {
+        await handleWorktreeInThread({ command, appId, thread: channel });
+        return;
+    }
+    // Handle command in text channel - create new thread with worktree (existing behavior)
+    if (channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels or threads');
+        return;
+    }
+    const rawName = command.options.getString('name');
+    if (!rawName) {
+        await command.editReply('Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`');
+        return;
+    }
+    const worktreeName = formatWorktreeName(rawName);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
         return;
     }
     const textChannel = channel;
@@ -167,3 +195,82 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         logger.error('[NEW-WORKTREE] Background error:', e);
     });
 }
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({ command, appId, thread, }) {
+    // Error if thread already has a worktree
+    if (getThreadWorktree(thread.id)) {
+        await command.editReply('This thread already has a worktree attached.');
+        return;
+    }
+    // Get worktree name from parameter or derive from thread name
+    const rawName = command.options.getString('name');
+    const worktreeName = rawName ? formatWorktreeName(rawName) : deriveWorktreeNameFromThread(thread.name);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please provide a name or rename the thread.');
+        return;
+    }
+    // Get parent channel for project directory
+    const parent = thread.parent;
+    if (!parent || parent.type !== ChannelType.GuildText) {
+        await command.editReply('Cannot determine parent channel');
+        return;
+    }
+    const projectDirectory = getProjectDirectoryFromChannel(parent, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    const existingWorktreePath = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktreePath) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
+        return;
+    }
+    // Store pending worktree in database for this existing thread
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    // Send status message in thread
+    const statusMessage = await thread.send({
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
+    // Create worktree in background
+    createWorktreeInBackground({
+        thread,
+        starterMessage: statusMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}

package/dist/database.js

@@ -91,6 +91,7 @@ export function getDatabase() {
     `);
         runModelMigrations(db);
         runWorktreeSettingsMigrations(db);
+        runVerbosityMigrations(db);
     }
     return db;
 }
@@ -267,6 +268,37 @@ export function runWorktreeSettingsMigrations(database) {
   `);
     dbLogger.log('Channel worktree settings migrations complete');
 }
+export function runVerbosityMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_verbosity (
+      channel_id TEXT PRIMARY KEY,
+      verbosity TEXT NOT NULL DEFAULT 'tools-and-text',
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Channel verbosity settings migrations complete');
+}
+/**
+ * Get the verbosity setting for a channel.
+ * @returns 'tools-and-text' (default) or 'text-only'
+ */
+export function getChannelVerbosity(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT verbosity FROM channel_verbosity WHERE channel_id = ?')
+        .get(channelId);
+    return row?.verbosity || 'tools-and-text';
+}
+/**
+ * Set the verbosity setting for a channel.
+ */
+export function setChannelVerbosity(channelId, verbosity) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_verbosity (channel_id, verbosity, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET verbosity = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, verbosity, verbosity);
+}
 /**
  * Check if automatic worktree creation is enabled for a channel.
  */
@@ -286,6 +318,23 @@ export function setChannelWorktreesEnabled(channelId, enabled) {
      VALUES (?, ?, CURRENT_TIMESTAMP)
      ON CONFLICT(channel_id) DO UPDATE SET enabled = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, enabled ? 1 : 0, enabled ? 1 : 0);
 }
+/**
+ * Get the directory and app_id for a channel from the database.
+ * This is the single source of truth for channel-project mappings.
+ */
+export function getChannelDirectory(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT directory, app_id FROM channel_directories WHERE channel_id = ?')
+        .get(channelId);
+    if (!row) {
+        return undefined;
+    }
+    return {
+        directory: row.directory,
+        appId: row.app_id,
+    };
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,7 +1,7 @@
 // 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 { getDatabase, closeDatabase, getThreadWorktree, createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelWorktreesEnabled, } from './database.js';
+import { getDatabase, closeDatabase, getThreadWorktree, createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelWorktreesEnabled, getChannelDirectory, } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js';
 import { formatWorktreeName } from './commands/worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
@@ -14,7 +14,7 @@ import { voiceConnections, cleanupVoiceConnection, processVoiceAttachment, regis
 import { getCompactSessionContext, getLastSessionId } from './markdown.js';
 import { handleOpencodeSession } from './session-handler.js';
 import { registerInteractionHandler } from './interaction-handler.js';
-export { getDatabase, closeDatabase } from './database.js';
+export { getDatabase, closeDatabase, getChannelDirectory } from './database.js';
 export { initializeOpencodeForDirectory } from './opencode.js';
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js';
 export { getOpencodeSystemMessage } from './system-message.js';
@@ -22,7 +22,6 @@ export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels,
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import * as errore from 'errore';
-import { extractTagsArrays } from './xml.js';
 import { createLogger } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
@@ -130,13 +129,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const parent = thread.parent;
                 let projectDirectory;
                 let channelAppId;
-                if (parent?.topic) {
-                    const extracted = extractTagsArrays({
-                        xml: parent.topic,
-                        tags: ['kimaki.directory', 'kimaki.app'],
-                    });
-                    projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-                    channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                if (parent) {
+                    const channelConfig = getChannelDirectory(parent.id);
+                    if (channelConfig) {
+                        projectDirectory = channelConfig.directory;
+                        channelAppId = channelConfig.appId || undefined;
+                    }
                 }
                 // Check if this thread is a worktree thread
                 const worktreeInfo = getThreadWorktree(thread.id);
@@ -155,9 +153,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         });
                         return;
                     }
-                    if (worktreeInfo.worktree_directory) {
-                        projectDirectory = worktreeInfo.worktree_directory;
-                        discordLogger.log(`Using worktree directory: ${projectDirectory}`);
+                    // Use original project directory for OpenCode server (session lives there)
+                    // The worktree directory is passed via query.directory in prompt/command calls
+                    if (worktreeInfo.project_directory) {
+                        projectDirectory = worktreeInfo.project_directory;
+                        discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.worktree_directory})`);
                     }
                 }
                 if (channelAppId && channelAppId !== currentAppId) {
@@ -271,20 +271,13 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (channel.type === ChannelType.GuildText) {
                 const textChannel = channel;
                 voiceLogger.log(`[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`);
-                if (!textChannel.topic) {
-                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no description`);
-                    return;
-                }
-                const extracted = extractTagsArrays({
-                    xml: textChannel.topic,
-                    tags: ['kimaki.directory', 'kimaki.app'],
-                });
-                const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-                if (!projectDirectory) {
-                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no kimaki.directory tag`);
+                const channelConfig = getChannelDirectory(textChannel.id);
+                if (!channelConfig) {
+                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no project directory configured`);
                     return;
                 }
+                const projectDirectory = channelConfig.directory;
+                const channelAppId = channelConfig.appId || undefined;
                 if (channelAppId && channelAppId !== currentAppId) {
                     voiceLogger.log(`[IGNORED] Channel belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`);
                     return;
@@ -437,21 +430,14 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);
                 return;
             }
-            // Extract directory from parent channel topic
-            if (!parent.topic) {
-                discordLogger.log(`[BOT_SESSION] Parent channel has no topic`);
-                return;
-            }
-            const extracted = extractTagsArrays({
-                xml: parent.topic,
-                tags: ['kimaki.directory', 'kimaki.app'],
-            });
-            const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-            const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-            if (!projectDirectory) {
-                discordLogger.log(`[BOT_SESSION] No kimaki.directory in parent channel topic`);
+            // Get directory from database
+            const channelConfig = getChannelDirectory(parent.id);
+            if (!channelConfig) {
+                discordLogger.log(`[BOT_SESSION] No project directory configured for parent channel`);
                 return;
             }
+            const projectDirectory = channelConfig.directory;
+            const channelAppId = channelConfig.appId || undefined;
             if (channelAppId && channelAppId !== currentAppId) {
                 discordLogger.log(`[BOT_SESSION] Channel belongs to different bot app`);
                 return;

package/dist/discord-utils.js

@@ -3,8 +3,8 @@
 // thread message sending, and channel metadata extraction from topic tags.
 import { ChannelType } from 'discord.js';
 import { Lexer } from 'marked';
-import { extractTagsArrays } from './xml.js';
 import { formatMarkdownTables } from './format-tables.js';
+import { getChannelDirectory } from './database.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
@@ -106,8 +106,14 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
         }
         return pieces;
     };
+    const closingFence = '```\n';
     for (const line of lines) {
-        const wouldExceed = currentChunk.length + line.text.length > maxLength;
+        const openingFenceSize = currentChunk.length === 0 && (line.inCodeBlock || line.isOpeningFence)
+            ? ('```' + line.lang + '\n').length
+            : 0;
+        const lineLength = line.isOpeningFence ? 0 : line.text.length;
+        const activeFenceOverhead = currentLang !== null || openingFenceSize > 0 ? closingFence.length : 0;
+        const wouldExceed = currentChunk.length + openingFenceSize + lineLength + activeFenceOverhead > maxLength;
         if (wouldExceed) {
             // handle case where single line is longer than maxLength
             if (line.text.length > maxLength) {
@@ -164,9 +170,37 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
             }
             else {
                 // currentChunk is empty but line still exceeds - shouldn't happen after above check
-                currentChunk = line.text;
-                if (line.inCodeBlock || line.isOpeningFence) {
-                    currentLang = line.lang;
+                const openingFence = line.inCodeBlock || line.isOpeningFence;
+                const openingFenceSize = openingFence ? ('```' + line.lang + '\n').length : 0;
+                if (line.text.length + openingFenceSize + activeFenceOverhead > maxLength) {
+                    const fencedOverhead = openingFence
+                        ? ('```' + line.lang + '\n').length + closingFence.length
+                        : 0;
+                    const availablePerChunk = Math.max(10, maxLength - fencedOverhead - 50);
+                    const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
+                    for (const piece of pieces) {
+                        if (openingFence) {
+                            chunks.push('```' + line.lang + '\n' + piece + closingFence);
+                        }
+                        else {
+                            chunks.push(piece);
+                        }
+                    }
+                    currentChunk = '';
+                    currentLang = null;
+                }
+                else {
+                    if (openingFence) {
+                        currentChunk = '```' + line.lang + '\n';
+                        if (!line.isOpeningFence) {
+                            currentChunk += line.text;
+                        }
+                        currentLang = line.lang;
+                    }
+                    else {
+                        currentChunk = line.text;
+                        currentLang = null;
+                    }
                 }
             }
         }
@@ -181,6 +215,9 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
         }
     }
     if (currentChunk) {
+        if (currentLang !== null) {
+            currentChunk += closingFence;
+        }
         chunks.push(currentChunk);
     }
     return chunks;
@@ -236,16 +273,17 @@ export function escapeDiscordFormatting(text) {
     return text.replace(/```/g, '\\`\\`\\`').replace(/````/g, '\\`\\`\\`\\`');
 }
 export function getKimakiMetadata(textChannel) {
-    if (!textChannel?.topic) {
+    if (!textChannel) {
         return {};
     }
-    const extracted = extractTagsArrays({
-        xml: textChannel.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-    });
-    const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-    const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-    return { projectDirectory, channelAppId };
+    const channelConfig = getChannelDirectory(textChannel.id);
+    if (!channelConfig) {
+        return {};
+    }
+    return {
+        projectDirectory: channelConfig.directory,
+        channelAppId: channelConfig.appId || undefined,
+    };
 }
 /**
  * Upload files to a Discord thread/channel in a single message.

package/dist/discord-utils.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { splitMarkdownForDiscord } from './discord-utils.js';
+describe('splitMarkdownForDiscord', () => {
+    test('never returns chunks over the max length with code fences', () => {
+        const maxLength = 2000;
+        const header = '## Summary of Current Architecture\n\n';
+        const codeFenceStart = '```\n';
+        const codeFenceEnd = '\n```\n';
+        const codeLine = 'x'.repeat(180);
+        const codeBlock = Array.from({ length: 20 })
+            .map(() => codeLine)
+            .join('\n');
+        const markdown = `${header}${codeFenceStart}${codeBlock}${codeFenceEnd}`;
+        const chunks = splitMarkdownForDiscord({ content: markdown, maxLength });
+        expect(chunks.length).toBeGreaterThan(1);
+        for (const chunk of chunks) {
+            expect(chunk.length).toBeLessThanOrEqual(maxLength);
+        }
+    });
+});

package/dist/escape-backticks.test.js

@@ -171,11 +171,17 @@ test('splitMarkdownForDiscord adds closing and opening fences when splitting cod
     [
       "\`\`\`js
     line1
+    \`\`\`
+    ",
+      "\`\`\`js
     line2
     \`\`\`
     ",
       "\`\`\`js
     line3
+    \`\`\`
+    ",
+      "\`\`\`js
     line4
     \`\`\`
     ",
@@ -209,10 +215,12 @@ test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
     [
       "Text before
     \`\`\`js
-    code
     \`\`\`
     ",
-      "Text after",
+      "\`\`\`js
+    code
+    \`\`\`
+    Text after",
     ]
   `);
 });
@@ -224,6 +232,9 @@ test('splitMarkdownForDiscord handles code block without language', () => {
     expect(result).toMatchInlineSnapshot(`
     [
       "\`\`\`
+    \`\`\`
+    ",
+      "\`\`\`
     line1
     \`\`\`
     ",
@@ -402,10 +413,10 @@ And here is some text after the code block.`;
 
     export function formatCurrency(amount: number): string {
       return new Intl.NumberFormat('en-US', {
-        style: 'currency',
     \`\`\`
     ",
       "\`\`\`typescript
+        style: 'currency',
         currency: 'USD',
       }).format(amount)
     }

package/dist/interaction-handler.js

@@ -20,6 +20,7 @@ import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
+import { handleVerbosityCommand } from './commands/verbosity.js';
 import { createLogger } from './logger.js';
 const interactionLogger = createLogger('INTERACTION');
 export function registerInteractionHandler({ discordClient, appId, }) {
@@ -108,6 +109,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'redo':
                         await handleRedoCommand({ command: interaction, appId });
                         return;
+                    case 'verbosity':
+                        await handleVerbosityCommand({ command: interaction, appId });
+                        return;
                 }
                 // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
                 if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {