kimaki 0.4.47 → 0.4.49

package/dist/cli.js

@@ -14,9 +14,18 @@ import { createLogger, LogPrefix } from './logger.js';
 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 { setDataDir, getDataDir, getLockPort, setDefaultVerbosity } from './config.js';
 import { sanitizeAgentName } from './commands/agent.js';
 const cliLogger = createLogger(LogPrefix.CLI);
+// Strip bracketed paste escape sequences from terminal input.
+// iTerm2 and other terminals wrap pasted content with \x1b[200~ and \x1b[201~
+// which can cause validation to fail on macOS. See: https://github.com/remorses/kimaki/issues/18
+function stripBracketedPaste(value) {
+    if (!value) {
+        return '';
+    }
+    return value.replace(/\x1b\[200~/g, '').replace(/\x1b\[201~/g, '').trim();
+}
 // Spawn caffeinate on macOS to prevent system sleep while bot is running.
 // Not detached, so it dies automatically with the parent process.
 function startCaffeinate() {
@@ -106,7 +115,8 @@ async function checkSingleInstance() {
             });
         }
     }
-    catch {
+    catch (error) {
+        cliLogger.debug('Lock port check failed:', error instanceof Error ? error.message : String(error));
         cliLogger.debug('No other kimaki instance detected on lock port');
     }
 }
@@ -399,11 +409,17 @@ async function backgroundInit({ currentDir, token, appId, }) {
             getClient()
                 .command.list({ query: { directory: currentDir } })
                 .then((r) => r.data || [])
-                .catch(() => []),
+                .catch((error) => {
+                cliLogger.warn('Failed to load user commands during background init:', error instanceof Error ? error.message : String(error));
+                return [];
+            }),
             getClient()
                 .app.agents({ query: { directory: currentDir } })
                 .then((r) => r.data || [])
-                .catch(() => []),
+                .catch((error) => {
+                cliLogger.warn('Failed to load agents during background init:', error instanceof Error ? error.message : String(error));
+                return [];
+            }),
         ]);
         await registerCommands({ token, appId, userCommands, agents });
         cliLogger.log('Slash commands registered!');
@@ -448,7 +464,8 @@ async function run({ restart, addChannels, useWorktrees }) {
                     fs.accessSync(p, fs.constants.F_OK);
                     return true;
                 }
-                catch {
+                catch (error) {
+                    cliLogger.debug(`OpenCode path not found at ${p}:`, error instanceof Error ? error.message : String(error));
                     return false;
                 }
             });
@@ -491,17 +508,20 @@ async function run({ restart, addChannels, useWorktrees }) {
             message: 'Enter your Discord Application ID:',
             placeholder: 'e.g., 1234567890123456789',
             validate(value) {
-                if (!value)
+                const cleaned = stripBracketedPaste(value);
+                if (!cleaned) {
                     return 'Application ID is required';
-                if (!/^\d{17,20}$/.test(value))
+                }
+                if (!/^\d{17,20}$/.test(cleaned)) {
                     return 'Invalid Application ID format (should be 17-20 digits)';
+                }
             },
         });
         if (isCancel(appIdInput)) {
             cancel('Setup cancelled');
             process.exit(0);
         }
-        appId = appIdInput;
+        appId = stripBracketedPaste(appIdInput);
         note('1. Go to the "Bot" section in the left sidebar\n' +
             '2. Scroll down to "Privileged Gateway Intents"\n' +
             '3. Enable these intents by toggling them ON:\n' +
@@ -522,33 +542,39 @@ async function run({ restart, addChannels, useWorktrees }) {
         const tokenInput = await password({
             message: 'Enter your Discord Bot Token (from "Bot" section - click "Reset Token" if needed):',
             validate(value) {
-                if (!value)
+                const cleaned = stripBracketedPaste(value);
+                if (!cleaned) {
                     return 'Bot token is required';
-                if (value.length < 50)
+                }
+                if (cleaned.length < 50) {
                     return 'Invalid token format (too short)';
+                }
             },
         });
         if (isCancel(tokenInput)) {
             cancel('Setup cancelled');
             process.exit(0);
         }
-        token = tokenInput;
+        token = stripBracketedPaste(tokenInput);
         note(`You can get a Gemini api Key at https://aistudio.google.com/apikey`, `Gemini API Key`);
-        const geminiApiKey = await password({
+        const geminiApiKeyInput = await password({
             message: 'Enter your Gemini API Key for voice channels and audio transcription (optional, press Enter to skip):',
             validate(value) {
-                if (value && value.length < 10)
+                const cleaned = stripBracketedPaste(value);
+                if (cleaned && cleaned.length < 10) {
                     return 'Invalid API key format';
+                }
                 return undefined;
             },
         });
-        if (isCancel(geminiApiKey)) {
+        if (isCancel(geminiApiKeyInput)) {
             cancel('Setup cancelled');
             process.exit(0);
         }
+        const geminiApiKey = stripBracketedPaste(geminiApiKeyInput) || null;
         // Store API key in database
         if (geminiApiKey) {
-            db.prepare('INSERT OR REPLACE INTO bot_api_keys (app_id, gemini_api_key) VALUES (?, ?)').run(appId, geminiApiKey || null);
+            db.prepare('INSERT OR REPLACE INTO bot_api_keys (app_id, gemini_api_key) VALUES (?, ?)').run(appId, geminiApiKey);
             note('API key saved successfully', 'API Key Stored');
         }
         note(`Bot install URL:\n${generateBotInstallUrl({ clientId: appId })}\n\nYou MUST install the bot in your Discord server before continuing.`, 'Step 4: Install Bot to Server');
@@ -676,11 +702,17 @@ async function run({ restart, addChannels, useWorktrees }) {
         getClient()
             .command.list({ query: { directory: currentDir } })
             .then((r) => r.data || [])
-            .catch(() => []),
+            .catch((error) => {
+            cliLogger.warn('Failed to load user commands during setup:', error instanceof Error ? error.message : String(error));
+            return [];
+        }),
         getClient()
             .app.agents({ query: { directory: currentDir } })
             .then((r) => r.data || [])
-            .catch(() => []),
+            .catch((error) => {
+            cliLogger.warn('Failed to load agents during setup:', error instanceof Error ? error.message : String(error));
+            return [];
+        }),
     ]);
     s.stop(`Found ${projects.length} OpenCode project(s)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
@@ -791,6 +823,7 @@ cli
     .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')
+    .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text or text-only)')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -798,6 +831,14 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.verbosity) {
+            if (options.verbosity !== 'tools-and-text' && options.verbosity !== 'text-only') {
+                cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use "tools-and-text" or "text-only".`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            setDefaultVerbosity(options.verbosity);
+            cliLogger.log(`Default verbosity: ${options.verbosity}`);
+        }
         if (options.installUrl) {
             const db = getDatabase();
             const existingBot = db
@@ -920,8 +961,8 @@ cli
                         .get();
                     appId = botRow?.app_id;
                 }
-                catch {
-                    // Database might not exist in CI, that's ok
+                catch (error) {
+                    cliLogger.debug('Database lookup failed while resolving app ID:', error instanceof Error ? error.message : String(error));
                 }
             }
         }
@@ -1017,8 +1058,8 @@ cli
                                     return ch.guild;
                                 }
                             }
-                            catch {
-                                // Channel might be deleted, continue
+                            catch (error) {
+                                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.message : String(error));
                             }
                         }
                         // Fall back to first guild the bot is in
@@ -1199,8 +1240,8 @@ cli
                         .get();
                     appId = botRow?.app_id;
                 }
-                catch {
-                    // Database might not exist in CI
+                catch (error) {
+                    cliLogger.debug('Database lookup failed while resolving app ID:', error instanceof Error ? error.message : String(error));
                 }
             }
         }
@@ -1270,8 +1311,8 @@ cli
                         throw new Error('Channel has no guild');
                     }
                 }
-                catch {
-                    // Channel might be deleted, fall back to first guild
+                catch (error) {
+                    cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.message : String(error));
                     const firstGuild = client.guilds.cache.first();
                     if (!firstGuild) {
                         s.stop('No guild found');
@@ -1310,13 +1351,13 @@ cli
                         process.exit(0);
                     }
                 }
-                catch {
-                    // Channel might be deleted, continue checking
+                catch (error) {
+                    cliLogger.debug(`Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`, error instanceof Error ? error.message : String(error));
                 }
             }
         }
-        catch {
-            // Database might not exist, continue to create
+        catch (error) {
+            cliLogger.debug('Database lookup failed while checking existing channels:', error instanceof Error ? error.message : String(error));
         }
         s.message(`Creating channels in ${guild.name}...`);
         const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({

package/dist/commands/abort.js

@@ -54,6 +54,7 @@ export async function handleAbortCommand({ command }) {
     const sessionId = row.session_id;
     const existingController = abortControllers.get(sessionId);
     if (existingController) {
+        logger.log(`[ABORT] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - user ran /abort command`);
         existingController.abort(new Error('User requested abort'));
         abortControllers.delete(sessionId);
     }
@@ -67,6 +68,7 @@ export async function handleAbortCommand({ command }) {
         return;
     }
     try {
+        logger.log(`[ABORT-API] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - sending API abort from /abort command`);
         await getClient().session.abort({
             path: { id: sessionId },
         });

package/dist/commands/create-new-project.js

@@ -1,13 +1,51 @@
 // /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 import { getProjectsDir } from '../config.js';
 import { createProjectChannels } from '../channel-management.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.CREATE_PROJECT);
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({ guild, projectName, appId, botName, }) {
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        return null;
+    }
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+        logger.log(`Created projects directory: ${projectsDir}`);
+    }
+    if (fs.existsSync(projectDirectory)) {
+        return null;
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    logger.log(`Created project directory: ${projectDirectory}`);
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+    logger.log(`Initialized git in: ${projectDirectory}`);
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+        botName,
+    });
+    return { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName };
+}
 export async function handleCreateNewProjectCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
     const projectName = command.options.getString('name', true);
@@ -21,37 +59,29 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
         await command.editReply('This command can only be used in a text channel');
         return;
     }
-    const sanitizedName = projectName
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 100);
-    if (!sanitizedName) {
-        await command.editReply('Invalid project name');
-        return;
-    }
-    const projectsDir = getProjectsDir();
-    const projectDirectory = path.join(projectsDir, sanitizedName);
     try {
-        if (!fs.existsSync(projectsDir)) {
-            fs.mkdirSync(projectsDir, { recursive: true });
-            logger.log(`Created projects directory: ${projectsDir}`);
-        }
-        if (fs.existsSync(projectDirectory)) {
-            await command.editReply(`Project directory already exists: ${projectDirectory}`);
-            return;
-        }
-        fs.mkdirSync(projectDirectory, { recursive: true });
-        logger.log(`Created project directory: ${projectDirectory}`);
-        const { execSync } = await import('node:child_process');
-        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
-        logger.log(`Initialized git in: ${projectDirectory}`);
-        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        const result = await createNewProject({
             guild,
-            projectDirectory,
+            projectName,
             appId,
+            botName: command.client.user?.username,
         });
+        if (!result) {
+            const sanitizedName = projectName
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '')
+                .slice(0, 100);
+            if (!sanitizedName) {
+                await command.editReply('Invalid project name');
+                return;
+            }
+            const projectDirectory = path.join(getProjectsDir(), sanitizedName);
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result;
         const textChannel = (await guild.channels.fetch(textChannelId));
         await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`);
         const starterMessage = await textChannel.send({

package/dist/commands/merge-worktree.js

@@ -38,7 +38,8 @@ async function isDetachedHead(worktreeDir) {
         await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`);
         return false;
     }
-    catch {
+    catch (error) {
+        logger.debug(`Failed to resolve HEAD for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
         return true;
     }
 }
@@ -50,7 +51,8 @@ async function getCurrentBranch(worktreeDir) {
         const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
         return stdout.trim() || null;
     }
-    catch {
+    catch (error) {
+        logger.debug(`Failed to get current branch for ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
         return null;
     }
 }
@@ -89,7 +91,8 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
             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 {
+        catch (error) {
+            logger.warn(`Failed to detect default branch for ${mainRepoDir}, falling back to main:`, error instanceof Error ? error.message : String(error));
             defaultBranch = 'main';
         }
         // 3. Determine if we're on a branch or detached HEAD
@@ -115,11 +118,17 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
         }
         catch (e) {
             // If merge fails (conflicts), abort and report
-            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => { });
+            await execAsync(`git -C "${worktreeDir}" merge --abort`).catch((error) => {
+                logger.warn(`Failed to abort merge in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
             // 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(() => { });
+                await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch((error) => {
+                    logger.warn(`Failed to detach HEAD after merge conflict in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
+                await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch((error) => {
+                    logger.warn(`Failed to delete temp branch ${tempBranch} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+                });
             }
             throw new Error(`Merge conflict - resolve manually in worktree then retry`);
         }
@@ -133,10 +142,14 @@ export async function handleMergeWorktreeCommand({ command, appId }) {
         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(() => { });
+        await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch((error) => {
+            logger.warn(`Failed to delete merged branch ${branchToMerge} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+        });
         // 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(() => { });
+            await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch((error) => {
+                logger.warn(`Failed to delete worktree branch ${worktreeInfo.worktree_name} in ${worktreeDir}:`, error instanceof Error ? error.message : String(error));
+            });
         }
         // 8. Remove worktree prefix from thread title (fire and forget with timeout)
         void removeWorktreePrefixFromTitle(thread);

package/dist/commands/permissions.js

@@ -13,7 +13,7 @@ export const pendingPermissionContexts = new Map();
  * Show permission dropdown for a permission request.
  * Returns the message ID and context hash for tracking.
  */
-export async function showPermissionDropdown({ thread, permission, directory, }) {
+export async function showPermissionDropdown({ thread, permission, directory, subtaskLabel, }) {
     const contextHash = crypto.randomBytes(8).toString('hex');
     const context = {
         permission,
@@ -47,8 +47,10 @@ export async function showPermissionDropdown({ thread, permission, directory, })
         .setPlaceholder('Choose an action')
         .addOptions(options);
     const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    const subtaskLine = subtaskLabel ? `**From:** \`${subtaskLabel}\`\n` : '';
     const permissionMessage = await thread.send({
         content: `⚠️ **Permission Required**\n\n` +
+            subtaskLine +
             `**Type:** \`${permission.permission}\`\n` +
             (patternStr ? `**Pattern:** \`${patternStr}\`` : ''),
         components: [actionRow],

package/dist/commands/session.js

@@ -105,7 +105,10 @@ async function handleAgentAutocomplete({ interaction, appId }) {
             return;
         }
         const agents = agentsResponse.data
-            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .filter((a) => {
+            const hidden = a.hidden;
+            return (a.mode === 'primary' || a.mode === 'all') && !hidden;
+        })
             .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
             .slice(0, 25);
         const choices = agents.map((agent) => ({

package/dist/commands/verbosity.js

@@ -8,7 +8,7 @@ import { createLogger, LogPrefix } from '../logger.js';
 const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
 /**
  * Handle the /verbosity slash command.
- * Sets output verbosity for the channel (applies to new sessions).
+ * Sets output verbosity for the channel (applies immediately, even mid-session).
  */
 export async function handleVerbosityCommand({ command, appId, }) {
     verbosityLogger.log('[VERBOSITY] Command called');
@@ -36,7 +36,7 @@ export async function handleVerbosityCommand({ command, appId, }) {
     const currentLevel = getChannelVerbosity(channelId);
     if (currentLevel === level) {
         await command.reply({
-            content: `Verbosity is already set to **${level}**.`,
+            content: `Verbosity is already set to **${level}** for this channel.`,
             ephemeral: true,
         });
         return;
@@ -47,7 +47,7 @@ export async function handleVerbosityCommand({ command, appId, }) {
         ? 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
         : 'All output will be shown, including tool executions and status messages.';
     await command.reply({
-        content: `Verbosity set to **${level}**.\n${description}\nThis applies to all new sessions in this channel.`,
+        content: `Verbosity set to **${level}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
         ephemeral: true,
     });
 }

package/dist/config.js

@@ -35,6 +35,13 @@ export function setDataDir(dir) {
 export function getProjectsDir() {
     return path.join(getDataDir(), 'projects');
 }
+let defaultVerbosity = 'tools-and-text';
+export function getDefaultVerbosity() {
+    return defaultVerbosity;
+}
+export function setDefaultVerbosity(level) {
+    defaultVerbosity = level;
+}
 const DEFAULT_LOCK_PORT = 29988;
 /**
  * Derive a lock port from the data directory path.

package/dist/database.js

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
-import { getDataDir } from './config.js';
+import { getDataDir, getDefaultVerbosity } from './config.js';
 const dbLogger = createLogger(LogPrefix.DB);
 let db = null;
 export function getDatabase() {
@@ -58,8 +58,8 @@ export function getDatabase() {
         try {
             db.exec(`ALTER TABLE channel_directories ADD COLUMN app_id TEXT`);
         }
-        catch {
-            // Column already exists, ignore
+        catch (error) {
+            dbLogger.debug('Failed to add app_id column to channel_directories (likely exists):', error instanceof Error ? error.message : String(error));
         }
         // Table for threads that should auto-start a session (created by CLI without --notify-only)
         db.exec(`
@@ -281,14 +281,17 @@ export function runVerbosityMigrations(database) {
 }
 /**
  * Get the verbosity setting for a channel.
- * @returns 'tools-and-text' (default) or 'text-only'
+ * Falls back to the global default set via --verbosity CLI flag if no per-channel override exists.
  */
 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';
+    if (row?.verbosity) {
+        return row.verbosity;
+    }
+    return getDefaultVerbosity();
 }
 /**
  * Set the verbosity setting for a channel.

package/dist/discord-bot.js

@@ -30,6 +30,9 @@ import { setGlobalDispatcher, Agent } from 'undici';
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const voiceLogger = createLogger(LogPrefix.VOICE);
+function prefixWithDiscordUser({ username, prompt }) {
+    return `<discord-user name="${username}" />\n${prompt}`;
+}
 export async function createDiscordClient() {
     return new Client({
         intents: [
@@ -93,6 +96,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (message.author?.bot) {
                 return;
             }
+            // Ignore messages that start with a mention of another user (not the bot).
+            // These are likely users talking to each other, not the bot.
+            const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/);
+            if (leadingMentionMatch) {
+                const mentionedUserId = leadingMentionMatch[1];
+                if (mentionedUserId !== discordClient.user?.id) {
+                    return;
+                }
+            }
             if (message.partial) {
                 discordLogger.log(`Fetching partial message ${message.id}`);
                 const fetched = await errore.tryAsync({
@@ -184,12 +196,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                     // Include starter message as context for the session
                     let prompt = message.content;
-                    const starterMessage = await thread.fetchStarterMessage().catch(() => null);
+                    const starterMessage = await thread.fetchStarterMessage().catch((error) => {
+                        discordLogger.warn(`[SESSION] Failed to fetch starter message for thread ${thread.id}:`, error instanceof Error ? error.message : String(error));
+                        return null;
+                    });
                     if (starterMessage?.content && starterMessage.content !== message.content) {
                         prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`;
                     }
                     await handleOpencodeSession({
-                        prompt,
+                        prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt }),
                         thread,
                         projectDirectory,
                         channelId: parent?.id || '',
@@ -259,7 +274,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     ? `${messageContent}\n\n${textAttachmentsContent}`
                     : messageContent;
                 await handleOpencodeSession({
-                    prompt: promptWithAttachments,
+                    prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt: promptWithAttachments }),
                     thread,
                     projectDirectory,
                     originalMessage: message,
@@ -379,7 +394,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     ? `${messageContent}\n\n${textAttachmentsContent}`
                     : messageContent;
                 await handleOpencodeSession({
-                    prompt: promptWithAttachments,
+                    prompt: prefixWithDiscordUser({ username: message.member?.displayName || message.author.displayName, prompt: promptWithAttachments }),
                     thread,
                     projectDirectory: sessionDirectory,
                     originalMessage: message,
@@ -397,8 +412,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const errMsg = error instanceof Error ? error.message : String(error);
                 await message.reply({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS });
             }
-            catch {
-                voiceLogger.error('Discord handler error (fallback):', error);
+            catch (sendError) {
+                voiceLogger.error('Discord handler error (fallback):', sendError instanceof Error ? sendError.message : String(sendError));
             }
         }
     });
@@ -416,7 +431,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 return;
             }
             // Get the starter message to check for auto-start marker
-            const starterMessage = await thread.fetchStarterMessage().catch(() => null);
+            const starterMessage = await thread.fetchStarterMessage().catch((error) => {
+                discordLogger.warn(`[THREAD_CREATE] Failed to fetch starter message for thread ${thread.id}:`, error instanceof Error ? error.message : String(error));
+                return null;
+            });
             if (!starterMessage) {
                 discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`);
                 return;
@@ -466,8 +484,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const errMsg = error instanceof Error ? error.message : String(error);
                 await thread.send({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS });
             }
-            catch {
-                // Ignore send errors
+            catch (sendError) {
+                voiceLogger.error('[BOT_SESSION] Failed to send error message:', sendError instanceof Error ? sendError.message : String(sendError));
             }
         }
     });