kimaki 0.4.46 → 0.4.48

package/dist/commands/model.js

@@ -5,9 +5,9 @@ import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } fro
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { abortAndRetrySession } from '../session-handler.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const modelLogger = createLogger('MODEL');
+const modelLogger = createLogger(LogPrefix.MODEL);
 // Store context by hash to avoid customId length limits (Discord max: 100 chars)
 const pendingModelContexts = new Map();
 /**
@@ -292,13 +292,13 @@ export async function handleModelSelectMenu(interaction) {
             }
             if (retried) {
                 await interaction.editReply({
-                    content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+                    content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\n_Retrying current request with new model..._`,
                     components: [],
                 });
             }
             else {
                 await interaction.editReply({
-                    content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+                    content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\``,
                     components: [],
                 });
             }
@@ -308,7 +308,7 @@ export async function handleModelSelectMenu(interaction) {
             setChannelModel(context.channelId, fullModelId);
             modelLogger.log(`Set model ${fullModelId} for channel ${context.channelId}`);
             await interaction.editReply({
-                content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\nAll new sessions in this channel will use this model.`,
+                content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\`${fullModelId}\`\nAll new sessions in this channel will use this model.`,
                 components: [],
             });
         }

package/dist/commands/permissions.js

@@ -5,15 +5,15 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { getOpencodeClientV2 } from '../opencode.js';
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('PERMISSIONS');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.PERMISSIONS);
 // Store pending permission contexts by hash
 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/queue.js

@@ -3,8 +3,8 @@ import { ChannelType } from 'discord.js';
 import { getDatabase } from '../database.js';
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { handleOpencodeSession, abortControllers, addToQueue, getQueueLength, clearQueue, } from '../session-handler.js';
-import { createLogger } from '../logger.js';
-const logger = createLogger('QUEUE');
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.QUEUE);
 export async function handleQueueCommand({ command }) {
     const message = command.options.getString('message', true);
     const channel = command.channel;

package/dist/commands/remove-project.js

@@ -2,9 +2,9 @@
 import path from 'node:path';
 import * as errore from 'errore';
 import { getDatabase } from '../database.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
-const logger = createLogger('REMOVE-PROJECT');
+const logger = createLogger(LogPrefix.REMOVE_PROJECT);
 export async function handleRemoveProjectCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const directory = command.options.getString('project', true);

package/dist/commands/resume.js

@@ -5,9 +5,9 @@ import { getDatabase, getChannelDirectory } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const logger = createLogger('RESUME');
+const logger = createLogger(LogPrefix.RESUME);
 export async function handleResumeCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const sessionId = command.options.getString('session', true);

package/dist/commands/session.js

@@ -6,9 +6,9 @@ import { getDatabase, getChannelDirectory } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { handleOpencodeSession } from '../session-handler.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const logger = createLogger('SESSION');
+const logger = createLogger(LogPrefix.SESSION);
 export async function handleSessionCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const prompt = command.options.getString('prompt', true);
@@ -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/share.js

@@ -3,9 +3,9 @@ import { ChannelType } from 'discord.js';
 import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const logger = createLogger('SHARE');
+const logger = createLogger(LogPrefix.SHARE);
 export async function handleShareCommand({ command }) {
     const channel = command.channel;
     if (!channel) {

package/dist/commands/undo-redo.js

@@ -3,9 +3,9 @@ import { ChannelType } from 'discord.js';
 import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
-const logger = createLogger('UNDO-REDO');
+const logger = createLogger(LogPrefix.UNDO_REDO);
 export async function handleUndoCommand({ command }) {
     const channel = command.channel;
     if (!channel) {

package/dist/commands/user-command.js

@@ -3,10 +3,10 @@
 import { ChannelType } from 'discord.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
+import { createLogger, LogPrefix } from '../logger.js';
 import { getDatabase, getChannelDirectory } from '../database.js';
 import fs from 'node:fs';
-const userCommandLogger = createLogger('USER_CMD');
+const userCommandLogger = createLogger(LogPrefix.USER_CMD);
 export const handleUserCommand = async ({ command, appId }) => {
     const discordCommandName = command.commandName;
     // Strip the -cmd suffix to get the actual OpenCode command name

package/dist/commands/verbosity.js

@@ -4,11 +4,11 @@
 // 'text-only': only shows text responses (⬥ diamond parts)
 import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
 import { getChannelVerbosity, setChannelVerbosity } from '../database.js';
-import { createLogger } from '../logger.js';
-const verbosityLogger = createLogger('VERBOSITY');
+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\n${description}\n\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/commands/worktree-settings.js

@@ -4,8 +4,8 @@
 import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
 import { getChannelWorktreesEnabled, setChannelWorktreesEnabled } from '../database.js';
 import { getKimakiMetadata } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
-const worktreeSettingsLogger = createLogger('WORKTREE_SETTINGS');
+import { createLogger, LogPrefix } from '../logger.js';
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE);
 /**
  * Handle the /enable-worktrees slash command.
  * Enables automatic worktree creation for new sessions in this channel.

package/dist/commands/worktree.js

@@ -6,11 +6,11 @@ import fs from 'node:fs';
 import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { createLogger } from '../logger.js';
-import { createWorktreeWithSubmodules } from '../worktree-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { createWorktreeWithSubmodules, captureGitDiff } from '../worktree-utils.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
-const logger = createLogger('WORKTREE');
+const logger = createLogger(LogPrefix.WORKTREE);
 class WorktreeError extends Error {
     constructor(message, options) {
         super(message, options);
@@ -69,14 +69,16 @@ function getProjectDirectoryFromChannel(channel, appId) {
 }
 /**
  * Create worktree in background and update starter message when done.
+ * If diff is provided, it's applied during worktree creation (before submodule init).
  */
-async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, }) {
-    // Create worktree using SDK v2 and init submodules
+async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, diff, }) {
+    // Create worktree using SDK v2, apply diff, then init submodules
     logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`);
     const worktreeResult = await createWorktreeWithSubmodules({
         clientV2,
         directory: projectDirectory,
         name: worktreeName,
+        diff,
     });
     if (worktreeResult instanceof Error) {
         const errorMsg = worktreeResult.message;
@@ -87,9 +89,11 @@ async function createWorktreeInBackground({ thread, starterMessage, worktreeName
     }
     // Success - update database and edit starter message
     setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory });
+    const diffStatus = diff ? (worktreeResult.diffApplied ? '\n✅ Changes applied' : '\n⚠️ Failed to apply changes') : '';
     await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n` +
         `📁 \`${worktreeResult.directory}\`\n` +
-        `🌿 Branch: \`${worktreeResult.branch}\``);
+        `🌿 Branch: \`${worktreeResult.branch}\`` +
+        diffStatus);
 }
 export async function handleNewWorktreeCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
@@ -253,6 +257,10 @@ async function handleWorktreeInThread({ command, appId, thread, }) {
         await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
         return;
     }
+    // Capture git diff from project directory before creating worktree.
+    // This allows transferring uncommitted changes to the new worktree.
+    const diff = await captureGitDiff(projectDirectory);
+    const hasDiff = diff && (diff.staged || diff.unstaged);
     // Store pending worktree in database for this existing thread
     createPendingWorktree({
         threadId: thread.id,
@@ -260,18 +268,20 @@ async function handleWorktreeInThread({ command, appId, thread, }) {
         projectDirectory,
     });
     // Send status message in thread
+    const diffNote = hasDiff ? '\n📋 Will transfer uncommitted changes' : '';
     const statusMessage = await thread.send({
-        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...${diffNote}`,
         flags: SILENT_MESSAGE_FLAGS,
     });
     await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
-    // Create worktree in background
+    // Create worktree in background, passing diff to apply after creation
     createWorktreeInBackground({
         thread,
         starterMessage: statusMessage,
         worktreeName,
         projectDirectory,
         clientV2,
+        diff,
     }).catch((e) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
     });

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

@@ -5,9 +5,9 @@ import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
-import { getDataDir } from './config.js';
-const dbLogger = createLogger('DB');
+import { createLogger, LogPrefix } from './logger.js';
+import { getDataDir, getDefaultVerbosity } from './config.js';
+const dbLogger = createLogger(LogPrefix.DB);
 let db = null;
 export function getDatabase() {
     if (!db) {
@@ -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

@@ -22,14 +22,17 @@ 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 { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
 // regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
-const discordLogger = createLogger('DISCORD');
-const voiceLogger = createLogger('VOICE');
+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));
             }
         }
     });

package/dist/discord-utils.js

@@ -7,11 +7,11 @@ 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';
+import { createLogger, LogPrefix } from './logger.js';
 import mime from 'mime';
 import fs from 'node:fs';
 import path from 'node:path';
-const discordLogger = createLogger('DISCORD');
+const discordLogger = createLogger(LogPrefix.DISCORD);
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
 // Same as SILENT but without SuppressNotifications - triggers badge/notification
 export const NOTIFY_MESSAGE_FLAGS = 4;

package/dist/genai-worker-wrapper.js

@@ -2,9 +2,9 @@
 // Spawns and manages the worker thread, handling message passing for
 // audio input/output, tool call completions, and graceful shutdown.
 import { Worker } from 'node:worker_threads';
-import { createLogger } from './logger.js';
-const genaiWorkerLogger = createLogger('GENAI WORKER');
-const genaiWrapperLogger = createLogger('GENAI WORKER WRAPPER');
+import { createLogger, LogPrefix } from './logger.js';
+const genaiWorkerLogger = createLogger(LogPrefix.GENAI_WORKER);
+const genaiWrapperLogger = createLogger(LogPrefix.GENAI_WORKER);
 export function createGenAIWorker(options) {
     return new Promise((resolve, reject) => {
         const worker = new Worker(new URL('../dist/genai-worker.js', import.meta.url));

package/dist/genai-worker.js

@@ -10,11 +10,11 @@ import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
 import { mkdir } from 'node:fs/promises';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
 }
-const workerLogger = createLogger(`WORKER ${threadId}`);
+const workerLogger = createLogger(`${LogPrefix.WORKER}_${threadId}`);
 workerLogger.log('GenAI worker started');
 // Define sendError early so it can be used by global handlers
 function sendError(error) {

package/dist/genai.js

@@ -3,9 +3,9 @@
 // and manages the assistant's audio output for Discord voice channels.
 import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session } from '@google/genai';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { aiToolToCallableTool } from './ai-tool-to-genai.js';
-const genaiLogger = createLogger('GENAI');
+const genaiLogger = createLogger(LogPrefix.GENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/interaction-handler.js

@@ -12,6 +12,7 @@ import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
 import { handlePermissionSelectMenu } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
+import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
@@ -21,8 +22,8 @@ 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');
+import { createLogger, LogPrefix } from './logger.js';
+const interactionLogger = createLogger(LogPrefix.INTERACTION);
 export function registerInteractionHandler({ discordClient, appId, }) {
     interactionLogger.log('[REGISTER] Interaction handler registered');
     discordClient.on(Events.InteractionCreate, async (interaction) => {
@@ -85,6 +86,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
+                    case 'compact':
+                        await handleCompactCommand({ command: interaction, appId });
+                        return;
                     case 'share':
                         await handleShareCommand({ command: interaction, appId });
                         return;