kernelbot 1.0.26 → 1.0.30

package/src/bot.js

@@ -1,8 +1,20 @@
 import TelegramBot from 'node-telegram-bot-api';
-import { createReadStream } from 'fs';
+import { createReadStream, readFileSync } from 'fs';
 import { isAllowedUser, getUnauthorizedMessage } from './security/auth.js';
 import { getLogger } from './utils/logger.js';
 import { PROVIDERS } from './providers/models.js';
+import {
+  getUnifiedSkillById,
+  getUnifiedCategoryList,
+  getUnifiedSkillsByCategory,
+  loadCustomSkills,
+  addCustomSkill,
+  deleteCustomSkill,
+  getCustomSkills,
+} from './skills/custom.js';
+import { TTSService } from './services/tts.js';
+import { STTService } from './services/stt.js';
+import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
 
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
@@ -41,12 +53,18 @@ class ChatQueue {
   }
 }
 
-export function startBot(config, agent, conversationManager) {
+export function startBot(config, agent, conversationManager, jobManager, automationManager) {
   const logger = getLogger();
   const bot = new TelegramBot(config.telegram.bot_token, { polling: true });
   const chatQueue = new ChatQueue();
   const batchWindowMs = config.telegram.batch_window_ms || 3000;
 
+  // Initialize voice services
+  const ttsService = new TTSService(config);
+  const sttService = new STTService(config);
+  if (ttsService.isAvailable()) logger.info('[Bot] TTS service enabled (ElevenLabs)');
+  if (sttService.isAvailable()) logger.info('[Bot] STT service enabled');
+
   // Per-chat message batching: chatId -> { messages[], timer, resolve }
   const chatBatches = new Map();
 
@@ -56,11 +74,108 @@ export function startBot(config, agent, conversationManager) {
     logger.info('Loaded previous conversations from disk');
   }
 
+  // Load custom skills from disk
+  loadCustomSkills();
+
+  // Register commands in Telegram's menu button
+  bot.setMyCommands([
+    { command: 'brain', description: 'Switch worker AI model/provider' },
+    { command: 'orchestrator', description: 'Switch orchestrator AI model/provider' },
+    { command: 'claudemodel', description: 'Switch Claude Code model' },
+    { command: 'claude', description: 'Manage Claude Code authentication' },
+    { command: 'skills', description: 'Browse and activate persona skills' },
+    { command: 'jobs', description: 'List running and recent jobs' },
+    { command: 'cancel', description: 'Cancel running job(s)' },
+    { command: 'auto', description: 'Manage recurring automations' },
+    { command: 'context', description: 'Show all models, auth, and context info' },
+    { command: 'clean', description: 'Clear conversation and start fresh' },
+    { command: 'history', description: 'Show message count in memory' },
+    { command: 'help', description: 'Show all available commands' },
+  ]).catch((err) => logger.warn(`Failed to set bot commands menu: ${err.message}`));
+
   logger.info('Telegram bot started with polling');
 
+  // Initialize automation manager with bot context
+  if (automationManager) {
+    const sendMsg = async (chatId, text) => {
+      try {
+        await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+      } catch {
+        await bot.sendMessage(chatId, text);
+      }
+    };
+
+    const sendAction = (chatId, action) => bot.sendChatAction(chatId, action).catch(() => {});
+
+    const agentFactory = (chatId) => {
+      const onUpdate = async (update, opts = {}) => {
+        if (opts.editMessageId) {
+          try {
+            const edited = await bot.editMessageText(update, {
+              chat_id: chatId,
+              message_id: opts.editMessageId,
+              parse_mode: 'Markdown',
+            });
+            return edited.message_id;
+          } catch {
+            try {
+              const edited = await bot.editMessageText(update, {
+                chat_id: chatId,
+                message_id: opts.editMessageId,
+              });
+              return edited.message_id;
+            } catch {
+              return opts.editMessageId;
+            }
+          }
+        }
+        const parts = splitMessage(update);
+        let lastMsgId = null;
+        for (const part of parts) {
+          try {
+            const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
+            lastMsgId = sent.message_id;
+          } catch {
+            const sent = await bot.sendMessage(chatId, part);
+            lastMsgId = sent.message_id;
+          }
+        }
+        return lastMsgId;
+      };
+
+      const sendPhoto = async (filePath, caption) => {
+        const fileOpts = { contentType: 'image/png' };
+        try {
+          await bot.sendPhoto(chatId, createReadStream(filePath), { caption: caption || '', parse_mode: 'Markdown' }, fileOpts);
+        } catch {
+          try {
+            await bot.sendPhoto(chatId, createReadStream(filePath), { caption: caption || '' }, fileOpts);
+          } catch (err) {
+            logger.error(`[Automation] Failed to send photo: ${err.message}`);
+          }
+        }
+      };
+
+      return { agent, onUpdate, sendPhoto };
+    };
+
+    automationManager.init({ sendMessage: sendMsg, sendChatAction: sendAction, agentFactory, config });
+    automationManager.startAll();
+    logger.info('[Bot] Automation manager initialized and started');
+  }
+
   // Track pending brain API key input: chatId -> { providerKey, modelId }
   const pendingBrainKey = new Map();
 
+  // Track pending orchestrator API key input: chatId -> { providerKey, modelId }
+  const pendingOrchKey = new Map();
+
+  // Track pending Claude Code auth input: chatId -> { type: 'api_key' | 'oauth_token' }
+  const pendingClaudeAuth = new Map();
+
+  // Track pending custom skill creation: chatId -> { step: 'name' | 'prompt', name?: string }
+  const pendingCustomSkill = new Map();
+
   // Handle inline keyboard callbacks for /brain
   bot.on('callback_query', async (query) => {
     const chatId = query.message.chat.id;
@@ -72,6 +187,8 @@ export function startBot(config, agent, conversationManager) {
     }
 
     try {
+      logger.info(`[Bot] Callback query from chat ${chatId}: ${data}`);
+
       if (data.startsWith('brain_provider:')) {
         // User picked a provider — show model list
         const providerKey = data.split(':')[1];
@@ -102,12 +219,35 @@ export function startBot(config, agent, conversationManager) {
         const modelEntry = providerDef?.models.find((m) => m.id === modelId);
         const modelLabel = modelEntry ? modelEntry.label : modelId;
 
-        const missing = agent.switchBrain(providerKey, modelId);
-        if (missing) {
+        await bot.editMessageText(
+          `⏳ Verifying *${providerDef.name}* / *${modelLabel}*...`,
+          {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+          },
+        );
+
+        logger.info(`[Bot] Brain switch request: ${providerKey}/${modelId} from chat ${chatId}`);
+        const result = await agent.switchBrain(providerKey, modelId);
+        if (result && typeof result === 'object' && result.error) {
+          // Validation failed — keep current model
+          logger.warn(`[Bot] Brain switch failed: ${result.error}`);
+          const current = agent.getBrainInfo();
+          await bot.editMessageText(
+            `❌ Failed to switch: ${result.error}\n\nKeeping *${current.providerName}* / *${current.modelLabel}*`,
+            {
+              chat_id: chatId,
+              message_id: query.message.message_id,
+              parse_mode: 'Markdown',
+            },
+          );
+        } else if (result) {
           // API key missing — ask for it
+          logger.info(`[Bot] Brain switch needs API key: ${result} for ${providerKey}/${modelId}`);
           pendingBrainKey.set(chatId, { providerKey, modelId });
           await bot.editMessageText(
-            `🔑 *${providerDef.name}* API key is required.\n\nPlease send your \`${missing}\` now.\n\nOr send *cancel* to abort.`,
+            `🔑 *${providerDef.name}* API key is required.\n\nPlease send your \`${result}\` now.\n\nOr send *cancel* to abort.`,
             {
               chat_id: chatId,
               message_id: query.message.message_id,
@@ -116,6 +256,7 @@ export function startBot(config, agent, conversationManager) {
           );
         } else {
           const info = agent.getBrainInfo();
+          logger.info(`[Bot] Brain switched successfully to ${info.providerName}/${info.modelLabel}`);
           await bot.editMessageText(
             `🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*`,
             {
@@ -134,9 +275,350 @@ export function startBot(config, agent, conversationManager) {
           message_id: query.message.message_id,
         });
         await bot.answerCallbackQuery(query.id);
+
+      // ── Skill callbacks ──────────────────────────────────────────
+      } else if (data.startsWith('skill_category:')) {
+        const categoryKey = data.split(':')[1];
+        const skills = getUnifiedSkillsByCategory(categoryKey);
+        const categories = getUnifiedCategoryList();
+        const cat = categories.find((c) => c.key === categoryKey);
+        if (!skills.length) {
+          await bot.answerCallbackQuery(query.id, { text: 'No skills in this category' });
+          return;
+        }
+
+        const activeSkill = agent.getActiveSkill(chatId);
+        const buttons = skills.map((s) => ([{
+          text: `${s.emoji} ${s.name}${activeSkill && activeSkill.id === s.id ? ' ✓' : ''}`,
+          callback_data: `skill_select:${s.id}`,
+        }]));
+        buttons.push([
+          { text: '« Back', callback_data: 'skill_back' },
+          { text: 'Cancel', callback_data: 'skill_cancel' },
+        ]);
+
+        await bot.editMessageText(
+          `${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — select a skill:`,
+          {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: { inline_keyboard: buttons },
+          },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('skill_select:')) {
+        const skillId = data.split(':')[1];
+        const skill = getUnifiedSkillById(skillId);
+        if (!skill) {
+          logger.warn(`[Bot] Unknown skill selected: ${skillId}`);
+          await bot.answerCallbackQuery(query.id, { text: 'Unknown skill' });
+          return;
+        }
+
+        logger.info(`[Bot] Skill activated: ${skill.name} (${skillId}) for chat ${chatId}`);
+        agent.setSkill(chatId, skillId);
+        await bot.editMessageText(
+          `${skill.emoji} *${skill.name}* activated!\n\n_${skill.description}_\n\nThe agent will now respond as this persona. Use /skills reset to return to default.`,
+          {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+          },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'skill_reset') {
+        logger.info(`[Bot] Skill reset for chat ${chatId}`);
+        agent.clearSkill(chatId);
+        await bot.editMessageText('🔄 Skill cleared — back to default persona.', {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'skill_custom_add') {
+        pendingCustomSkill.set(chatId, { step: 'name' });
+        await bot.editMessageText(
+          '✏️ Send me a *name* for your custom skill:',
+          {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+          },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'skill_custom_manage') {
+        const customs = getCustomSkills();
+        if (!customs.length) {
+          await bot.answerCallbackQuery(query.id, { text: 'No custom skills yet' });
+          return;
+        }
+        const buttons = customs.map((s) => ([{
+          text: `🗑️ ${s.name}`,
+          callback_data: `skill_custom_delete:${s.id}`,
+        }]));
+        buttons.push([{ text: '« Back', callback_data: 'skill_back' }]);
+
+        await bot.editMessageText('🛠️ *Custom Skills* — tap to delete:', {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('skill_custom_delete:')) {
+        const skillId = data.slice('skill_custom_delete:'.length);
+        logger.info(`[Bot] Custom skill delete request: ${skillId} from chat ${chatId}`);
+        const activeSkill = agent.getActiveSkill(chatId);
+        if (activeSkill && activeSkill.id === skillId) {
+          logger.info(`[Bot] Clearing active skill before deletion: ${skillId}`);
+          agent.clearSkill(chatId);
+        }
+        const deleted = deleteCustomSkill(skillId);
+        const msg = deleted ? '🗑️ Custom skill deleted.' : 'Skill not found.';
+        await bot.editMessageText(msg, {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'skill_back') {
+        // Re-show category list
+        const categories = getUnifiedCategoryList();
+        const activeSkill = agent.getActiveSkill(chatId);
+        const buttons = categories.map((cat) => ([{
+          text: `${cat.emoji} ${cat.name} (${cat.count})`,
+          callback_data: `skill_category:${cat.key}`,
+        }]));
+        // Custom skill management row
+        const customRow = [{ text: '➕ Add Custom', callback_data: 'skill_custom_add' }];
+        if (getCustomSkills().length > 0) {
+          customRow.push({ text: '🗑️ Manage Custom', callback_data: 'skill_custom_manage' });
+        }
+        buttons.push(customRow);
+        const footerRow = [{ text: 'Cancel', callback_data: 'skill_cancel' }];
+        if (activeSkill) {
+          footerRow.unshift({ text: '🔄 Reset to Default', callback_data: 'skill_reset' });
+        }
+        buttons.push(footerRow);
+
+        const header = activeSkill
+          ? `🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n\nSelect a category:`
+          : '🎭 *Skills* — select a category:';
+
+        await bot.editMessageText(header, {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'skill_cancel') {
+        await bot.editMessageText('Skill selection cancelled.', {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Job cancellation callbacks ────────────────────────────────
+      } else if (data.startsWith('cancel_job:')) {
+        const jobId = data.slice('cancel_job:'.length);
+        logger.info(`[Bot] Job cancel request via callback: ${jobId} from chat ${chatId}`);
+        const job = jobManager.cancelJob(jobId);
+        if (job) {
+          logger.info(`[Bot] Job cancelled via callback: ${jobId} [${job.workerType}]`);
+          await bot.editMessageText(`🚫 Cancelled job \`${jobId}\` (${job.workerType})`, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+          });
+        } else {
+          await bot.editMessageText(`Job \`${jobId}\` not found or already finished.`, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+          });
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'cancel_all_jobs') {
+        logger.info(`[Bot] Cancel all jobs request via callback from chat ${chatId}`);
+        const cancelled = jobManager.cancelAllForChat(chatId);
+        const msg = cancelled.length > 0
+          ? `🚫 Cancelled ${cancelled.length} job(s).`
+          : 'No running jobs to cancel.';
+        await bot.editMessageText(msg, {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Automation callbacks ─────────────────────────────────────────
+      } else if (data.startsWith('auto_pause:')) {
+        const autoId = data.slice('auto_pause:'.length);
+        logger.info(`[Bot] Automation pause request: ${autoId} from chat ${chatId}`);
+        const auto = automationManager?.update(autoId, { enabled: false });
+        const msg = auto ? `⏸️ Paused automation \`${autoId}\` (${auto.name})` : `Automation \`${autoId}\` not found.`;
+        await bot.editMessageText(msg, { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('auto_resume:')) {
+        const autoId = data.slice('auto_resume:'.length);
+        logger.info(`[Bot] Automation resume request: ${autoId} from chat ${chatId}`);
+        const auto = automationManager?.update(autoId, { enabled: true });
+        const msg = auto ? `▶️ Resumed automation \`${autoId}\` (${auto.name})` : `Automation \`${autoId}\` not found.`;
+        await bot.editMessageText(msg, { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('auto_delete:')) {
+        const autoId = data.slice('auto_delete:'.length);
+        logger.info(`[Bot] Automation delete request: ${autoId} from chat ${chatId}`);
+        const deleted = automationManager?.delete(autoId);
+        const msg = deleted ? `🗑️ Deleted automation \`${autoId}\`` : `Automation \`${autoId}\` not found.`;
+        await bot.editMessageText(msg, { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Orchestrator callbacks ─────────────────────────────────────
+      } else if (data.startsWith('orch_provider:')) {
+        const providerKey = data.split(':')[1];
+        const providerDef = PROVIDERS[providerKey];
+        if (!providerDef) {
+          await bot.answerCallbackQuery(query.id, { text: 'Unknown provider' });
+          return;
+        }
+
+        const modelButtons = providerDef.models.map((m) => ([{
+          text: m.label,
+          callback_data: `orch_model:${providerKey}:${m.id}`,
+        }]));
+        modelButtons.push([{ text: 'Cancel', callback_data: 'orch_cancel' }]);
+
+        await bot.editMessageText(`Select a *${providerDef.name}* model for orchestrator:`, {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: modelButtons },
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('orch_model:')) {
+        const [, providerKey, modelId] = data.split(':');
+        const providerDef = PROVIDERS[providerKey];
+        const modelEntry = providerDef?.models.find((m) => m.id === modelId);
+        const modelLabel = modelEntry ? modelEntry.label : modelId;
+
+        await bot.editMessageText(
+          `⏳ Verifying *${providerDef.name}* / *${modelLabel}* for orchestrator...`,
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+
+        logger.info(`[Bot] Orchestrator switch request: ${providerKey}/${modelId} from chat ${chatId}`);
+        const result = await agent.switchOrchestrator(providerKey, modelId);
+        if (result && typeof result === 'object' && result.error) {
+          const current = agent.getOrchestratorInfo();
+          await bot.editMessageText(
+            `❌ Failed to switch: ${result.error}\n\nKeeping *${current.providerName}* / *${current.modelLabel}*`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        } else if (result) {
+          // API key missing
+          logger.info(`[Bot] Orchestrator switch needs API key: ${result} for ${providerKey}/${modelId}`);
+          pendingOrchKey.set(chatId, { providerKey, modelId });
+          await bot.editMessageText(
+            `🔑 *${providerDef.name}* API key is required.\n\nPlease send your \`${result}\` now.\n\nOr send *cancel* to abort.`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        } else {
+          const info = agent.getOrchestratorInfo();
+          await bot.editMessageText(
+            `🎛️ Orchestrator switched to *${info.providerName}* / *${info.modelLabel}*`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'orch_cancel') {
+        pendingOrchKey.delete(chatId);
+        await bot.editMessageText('Orchestrator change cancelled.', {
+          chat_id: chatId, message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Claude Code model callbacks ────────────────────────────────
+      } else if (data.startsWith('ccmodel:')) {
+        const modelId = data.slice('ccmodel:'.length);
+        agent.switchClaudeCodeModel(modelId);
+        const info = agent.getClaudeCodeInfo();
+        logger.info(`[Bot] Claude Code model switched to ${info.modelLabel} from chat ${chatId}`);
+        await bot.editMessageText(
+          `💻 Claude Code model switched to *${info.modelLabel}*`,
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'ccmodel_cancel') {
+        await bot.editMessageText('Claude Code model change cancelled.', {
+          chat_id: chatId, message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Claude Code auth callbacks ─────────────────────────────────
+      } else if (data === 'claude_apikey') {
+        pendingClaudeAuth.set(chatId, { type: 'api_key' });
+        await bot.editMessageText(
+          '🔑 Send your *Anthropic API key* for Claude Code.\n\nOr send *cancel* to abort.',
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'claude_oauth') {
+        pendingClaudeAuth.set(chatId, { type: 'oauth_token' });
+        await bot.editMessageText(
+          '🔑 Run `claude setup-token` locally and paste the *OAuth token* here.\n\nThis uses your Pro/Max subscription instead of an API key.\n\nOr send *cancel* to abort.',
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'claude_system') {
+        agent.setClaudeCodeAuth('system', null);
+        logger.info(`[Bot] Claude Code auth set to system from chat ${chatId}`);
+        await bot.editMessageText(
+          '🔓 Claude Code set to *system auth* — using host machine credentials.',
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'claude_status') {
+        await bot.answerCallbackQuery(query.id, { text: 'Checking...' });
+        const status = await getClaudeAuthStatus();
+        const authConfig = agent.getClaudeAuthConfig();
+        await bot.editMessageText(
+          `🔐 *Claude Code Auth*\n\n*Mode:* ${authConfig.mode}\n*Credential:* ${authConfig.credential}\n\n*CLI Status:*\n\`\`\`\n${status.output.slice(0, 500)}\n\`\`\``,
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+
+      } else if (data === 'claude_logout') {
+        await bot.answerCallbackQuery(query.id, { text: 'Logging out...' });
+        const result = await claudeLogout();
+        await bot.editMessageText(
+          `🚪 Claude Code logout: ${result.output || 'Done.'}`,
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+
+      } else if (data === 'claude_cancel') {
+        pendingClaudeAuth.delete(chatId);
+        await bot.editMessageText('Claude Code auth management dismissed.', {
+          chat_id: chatId, message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
       }
     } catch (err) {
-      logger.error(`Callback query error: ${err.message}`);
+      logger.error(`[Bot] Callback query error for "${data}" in chat ${chatId}: ${err.message}`);
       await bot.answerCallbackQuery(query.id, { text: 'Error' });
     }
   });
@@ -167,6 +649,10 @@ export function startBot(config, agent, conversationManager) {
           ? batch.messages[0]
           : batch.messages.map((m, i) => `[${i + 1}]: ${m}`).join('\n\n');
 
+        if (batch.messages.length > 1) {
+          logger.info(`[Bot] Batch merged ${batch.messages.length} messages for chat ${key}`);
+        }
+
         // First resolver gets the merged text, rest get null (skip)
         batch.resolvers[0](merged);
         for (let i = 1; i < batch.resolvers.length; i++) {
@@ -177,19 +663,82 @@ export function startBot(config, agent, conversationManager) {
   }
 
   bot.on('message', async (msg) => {
-    if (!msg.text) return; // ignore non-text
-
     const chatId = msg.chat.id;
     const userId = msg.from.id;
     const username = msg.from.username || msg.from.first_name || 'unknown';
 
     // Auth check
     if (!isAllowedUser(userId, config)) {
-      logger.warn(`Unauthorized access attempt from ${username} (${userId})`);
-      await bot.sendMessage(chatId, getUnauthorizedMessage());
+      if (msg.text || msg.document) {
+        logger.warn(`Unauthorized access attempt from ${username} (${userId})`);
+        await bot.sendMessage(chatId, getUnauthorizedMessage());
+      }
       return;
     }
 
+    // Handle file upload for pending custom skill prompt step
+    if (msg.document && pendingCustomSkill.has(chatId)) {
+      const pending = pendingCustomSkill.get(chatId);
+      if (pending.step === 'prompt') {
+        const doc = msg.document;
+        const mime = doc.mime_type || '';
+        const fname = doc.file_name || '';
+        if (!fname.endsWith('.md') && mime !== 'text/markdown' && mime !== 'text/plain') {
+          await bot.sendMessage(chatId, 'Please upload a `.md` or plain text file, or type the prompt directly.');
+          return;
+        }
+        try {
+          const filePath = await bot.downloadFile(doc.file_id, '/tmp');
+          const content = readFileSync(filePath, 'utf-8').trim();
+          if (!content) {
+            await bot.sendMessage(chatId, 'The file appears to be empty. Please try again.');
+            return;
+          }
+          pendingCustomSkill.delete(chatId);
+          const skill = addCustomSkill({ name: pending.name, systemPrompt: content });
+          logger.info(`[Bot] Custom skill created from file: "${skill.name}" (${skill.id}) — ${content.length} chars, by ${username} in chat ${chatId}`);
+          agent.setSkill(chatId, skill.id);
+          await bot.sendMessage(
+            chatId,
+            `✅ Custom skill *${skill.name}* created and activated!\n\n_Prompt loaded from file (${content.length} chars)_`,
+            { parse_mode: 'Markdown' },
+          );
+        } catch (err) {
+          logger.error(`Custom skill file upload error: ${err.message}`);
+          await bot.sendMessage(chatId, `Failed to read file: ${err.message}`);
+        }
+        return;
+      }
+    }
+
+    // Handle voice messages — transcribe and process as text
+    if (msg.voice && sttService.isAvailable()) {
+      logger.info(`[Bot] Voice message from ${username} (${userId}) in chat ${chatId}, duration: ${msg.voice.duration}s`);
+      let tmpPath = null;
+      try {
+        const fileUrl = await bot.getFileLink(msg.voice.file_id);
+        tmpPath = await sttService.downloadAudio(fileUrl);
+        const transcribed = await sttService.transcribe(tmpPath);
+        if (!transcribed) {
+          await bot.sendMessage(chatId, 'Could not transcribe the voice message. Please try again or send text.');
+          return;
+        }
+        logger.info(`[Bot] Transcribed voice: "${transcribed.slice(0, 100)}" from ${username} in chat ${chatId}`);
+        // Show the user what was heard
+        await bot.sendMessage(chatId, `🎤 _"${transcribed}"_`, { parse_mode: 'Markdown' });
+        // Process as a normal text message (fall through below)
+        msg.text = transcribed;
+      } catch (err) {
+        logger.error(`[Bot] Voice transcription failed: ${err.message}`);
+        await bot.sendMessage(chatId, 'Failed to process voice message. Please try sending text instead.');
+        return;
+      } finally {
+        if (tmpPath) sttService.cleanup(tmpPath);
+      }
+    }
+
+    if (!msg.text) return; // ignore non-text (and non-document) messages
+
     let text = msg.text.trim();
 
     // Handle pending brain API key input
@@ -198,22 +747,125 @@ export function startBot(config, agent, conversationManager) {
       pendingBrainKey.delete(chatId);
 
       if (text.toLowerCase() === 'cancel') {
+        logger.info(`[Bot] Brain key input cancelled by ${username} in chat ${chatId}`);
         await bot.sendMessage(chatId, 'Brain change cancelled.');
         return;
       }
 
-      agent.switchBrainWithKey(pending.providerKey, pending.modelId, text);
-      const info = agent.getBrainInfo();
+      logger.info(`[Bot] Brain key received for ${pending.providerKey}/${pending.modelId} from ${username} in chat ${chatId}`);
+      await bot.sendMessage(chatId, '⏳ Verifying API key...');
+      const switchResult = await agent.switchBrainWithKey(pending.providerKey, pending.modelId, text);
+      if (switchResult && switchResult.error) {
+        const current = agent.getBrainInfo();
+        await bot.sendMessage(
+          chatId,
+          `❌ Failed to switch: ${switchResult.error}\n\nKeeping *${current.providerName}* / *${current.modelLabel}*`,
+          { parse_mode: 'Markdown' },
+        );
+      } else {
+        const info = agent.getBrainInfo();
+        await bot.sendMessage(
+          chatId,
+          `🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*\n\nAPI key saved.`,
+          { parse_mode: 'Markdown' },
+        );
+      }
+      return;
+    }
+
+    // Handle pending orchestrator API key input
+    if (pendingOrchKey.has(chatId)) {
+      const pending = pendingOrchKey.get(chatId);
+      pendingOrchKey.delete(chatId);
+
+      if (text.toLowerCase() === 'cancel') {
+        logger.info(`[Bot] Orchestrator key input cancelled by ${username} in chat ${chatId}`);
+        await bot.sendMessage(chatId, 'Orchestrator change cancelled.');
+        return;
+      }
+
+      logger.info(`[Bot] Orchestrator key received for ${pending.providerKey}/${pending.modelId} from ${username} in chat ${chatId}`);
+      await bot.sendMessage(chatId, '⏳ Verifying API key...');
+      const switchResult = await agent.switchOrchestratorWithKey(pending.providerKey, pending.modelId, text);
+      if (switchResult && switchResult.error) {
+        const current = agent.getOrchestratorInfo();
+        await bot.sendMessage(
+          chatId,
+          `❌ Failed to switch: ${switchResult.error}\n\nKeeping *${current.providerName}* / *${current.modelLabel}*`,
+          { parse_mode: 'Markdown' },
+        );
+      } else {
+        const info = agent.getOrchestratorInfo();
+        await bot.sendMessage(
+          chatId,
+          `🎛️ Orchestrator switched to *${info.providerName}* / *${info.modelLabel}*\n\nAPI key saved.`,
+          { parse_mode: 'Markdown' },
+        );
+      }
+      return;
+    }
+
+    // Handle pending Claude Code auth input
+    if (pendingClaudeAuth.has(chatId)) {
+      const pending = pendingClaudeAuth.get(chatId);
+      pendingClaudeAuth.delete(chatId);
+
+      if (text.toLowerCase() === 'cancel') {
+        logger.info(`[Bot] Claude Code auth input cancelled by ${username} in chat ${chatId}`);
+        await bot.sendMessage(chatId, 'Claude Code auth setup cancelled.');
+        return;
+      }
+
+      agent.setClaudeCodeAuth(pending.type, text);
+      const label = pending.type === 'api_key' ? 'API Key' : 'OAuth Token';
+      logger.info(`[Bot] Claude Code ${label} saved from ${username} in chat ${chatId}`);
       await bot.sendMessage(
         chatId,
-        `🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*\n\nAPI key saved.`,
+        `🔐 Claude Code *${label}* saved and activated.\n\nNext Claude Code spawn will use this credential.`,
         { parse_mode: 'Markdown' },
       );
       return;
     }
 
+    // Handle pending custom skill creation (text input for name or prompt)
+    if (pendingCustomSkill.has(chatId)) {
+      const pending = pendingCustomSkill.get(chatId);
+
+      if (text.toLowerCase() === 'cancel') {
+        pendingCustomSkill.delete(chatId);
+        await bot.sendMessage(chatId, 'Custom skill creation cancelled.');
+        return;
+      }
+
+      if (pending.step === 'name') {
+        pending.name = text;
+        pending.step = 'prompt';
+        pendingCustomSkill.set(chatId, pending);
+        await bot.sendMessage(
+          chatId,
+          `Got it: *${text}*\n\nNow send the system prompt — type it out or upload a \`.md\` file:`,
+          { parse_mode: 'Markdown' },
+        );
+        return;
+      }
+
+      if (pending.step === 'prompt') {
+        pendingCustomSkill.delete(chatId);
+        const skill = addCustomSkill({ name: pending.name, systemPrompt: text });
+        logger.info(`[Bot] Custom skill created: "${skill.name}" (${skill.id}) by ${username} in chat ${chatId}`);
+        agent.setSkill(chatId, skill.id);
+        await bot.sendMessage(
+          chatId,
+          `✅ Custom skill *${skill.name}* created and activated!`,
+          { parse_mode: 'Markdown' },
+        );
+        return;
+      }
+    }
+
     // Handle commands — these bypass batching entirely
     if (text === '/brain') {
+      logger.info(`[Bot] /brain command from ${username} (${userId}) in chat ${chatId}`);
       const info = agent.getBrainInfo();
       const providerKeys = Object.keys(PROVIDERS);
       const buttons = providerKeys.map((key) => ([{
@@ -233,6 +885,116 @@ export function startBot(config, agent, conversationManager) {
       return;
     }
 
+    if (text === '/orchestrator') {
+      logger.info(`[Bot] /orchestrator command from ${username} (${userId}) in chat ${chatId}`);
+      const info = agent.getOrchestratorInfo();
+      const providerKeys = Object.keys(PROVIDERS);
+      const buttons = providerKeys.map((key) => ([{
+        text: `${PROVIDERS[key].name}${key === info.provider ? ' ✓' : ''}`,
+        callback_data: `orch_provider:${key}`,
+      }]));
+      buttons.push([{ text: 'Cancel', callback_data: 'orch_cancel' }]);
+
+      await bot.sendMessage(
+        chatId,
+        `🎛️ *Current orchestrator:* ${info.providerName} / ${info.modelLabel}\n\nSelect a provider to switch:`,
+        {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        },
+      );
+      return;
+    }
+
+    if (text === '/claudemodel') {
+      logger.info(`[Bot] /claudemodel command from ${username} (${userId}) in chat ${chatId}`);
+      const info = agent.getClaudeCodeInfo();
+      const anthropicModels = PROVIDERS.anthropic.models;
+      const buttons = anthropicModels.map((m) => ([{
+        text: `${m.label}${m.id === info.model ? ' ✓' : ''}`,
+        callback_data: `ccmodel:${m.id}`,
+      }]));
+      buttons.push([{ text: 'Cancel', callback_data: 'ccmodel_cancel' }]);
+
+      await bot.sendMessage(
+        chatId,
+        `💻 *Current Claude Code model:* ${info.modelLabel}\n\nSelect a model:`,
+        {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        },
+      );
+      return;
+    }
+
+    if (text === '/claude') {
+      logger.info(`[Bot] /claude command from ${username} (${userId}) in chat ${chatId}`);
+      const authConfig = agent.getClaudeAuthConfig();
+      const ccInfo = agent.getClaudeCodeInfo();
+
+      const modeLabels = { system: '🔓 System Login', api_key: '🔑 API Key', oauth_token: '🎫 OAuth Token (Pro/Max)' };
+      const modeLabel = modeLabels[authConfig.mode] || authConfig.mode;
+
+      const buttons = [
+        [{ text: '🔑 Set API Key', callback_data: 'claude_apikey' }],
+        [{ text: '🎫 Set OAuth Token (Pro/Max)', callback_data: 'claude_oauth' }],
+        [{ text: '🔓 Use System Auth', callback_data: 'claude_system' }],
+        [
+          { text: '🔄 Refresh Status', callback_data: 'claude_status' },
+          { text: '🚪 Logout', callback_data: 'claude_logout' },
+        ],
+        [{ text: 'Cancel', callback_data: 'claude_cancel' }],
+      ];
+
+      await bot.sendMessage(
+        chatId,
+        `🔐 *Claude Code Auth*\n\n*Auth Mode:* ${modeLabel}\n*Credential:* ${authConfig.credential}\n*Model:* ${ccInfo.modelLabel}\n\nSelect an action:`,
+        {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        },
+      );
+      return;
+    }
+
+    if (text === '/skills reset' || text === '/skill reset') {
+      logger.info(`[Bot] /skills reset from ${username} (${userId}) in chat ${chatId}`);
+      agent.clearSkill(chatId);
+      await bot.sendMessage(chatId, '🔄 Skill cleared — back to default persona.');
+      return;
+    }
+
+    if (text === '/skills' || text === '/skill') {
+      logger.info(`[Bot] /skills command from ${username} (${userId}) in chat ${chatId}`);
+      const categories = getUnifiedCategoryList();
+      const activeSkill = agent.getActiveSkill(chatId);
+      const buttons = categories.map((cat) => ([{
+        text: `${cat.emoji} ${cat.name} (${cat.count})`,
+        callback_data: `skill_category:${cat.key}`,
+      }]));
+      // Custom skill management row
+      const customRow = [{ text: '➕ Add Custom', callback_data: 'skill_custom_add' }];
+      if (getCustomSkills().length > 0) {
+        customRow.push({ text: '🗑️ Manage Custom', callback_data: 'skill_custom_manage' });
+      }
+      buttons.push(customRow);
+      const footerRow = [{ text: 'Cancel', callback_data: 'skill_cancel' }];
+      if (activeSkill) {
+        footerRow.unshift({ text: '🔄 Reset to Default', callback_data: 'skill_reset' });
+      }
+      buttons.push(footerRow);
+
+      const header = activeSkill
+        ? `🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n\nSelect a category:`
+        : '🎭 *Skills* — select a category:';
+
+      await bot.sendMessage(chatId, header, {
+        parse_mode: 'Markdown',
+        reply_markup: { inline_keyboard: buttons },
+      });
+      return;
+    }
+
     if (text === '/clean' || text === '/clear' || text === '/reset') {
       conversationManager.clear(chatId);
       logger.info(`Conversation cleared for chat ${chatId} by ${username}`);
@@ -246,11 +1008,116 @@ export function startBot(config, agent, conversationManager) {
       return;
     }
 
+    if (text === '/context') {
+      const info = agent.getBrainInfo();
+      const orchInfo = agent.getOrchestratorInfo();
+      const ccInfo = agent.getClaudeCodeInfo();
+      const authConfig = agent.getClaudeAuthConfig();
+      const activeSkill = agent.getActiveSkill(chatId);
+      const msgCount = conversationManager.getMessageCount(chatId);
+      const history = conversationManager.getHistory(chatId);
+      const maxHistory = conversationManager.maxHistory;
+      const recentWindow = conversationManager.recentWindow;
+
+      // Build recent topics from last few user messages
+      const recentUserMsgs = history
+        .filter((m) => m.role === 'user')
+        .slice(-5)
+        .map((m) => {
+          const txt = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+          return txt.length > 80 ? txt.slice(0, 80) + '…' : txt;
+        });
+
+      const lines = [
+        '📋 *Conversation Context*',
+        '',
+        `🎛️ *Orchestrator:* ${orchInfo.providerName} / ${orchInfo.modelLabel}`,
+        `🧠 *Brain (Workers):* ${info.providerName} / ${info.modelLabel}`,
+        `💻 *Claude Code:* ${ccInfo.modelLabel} (auth: ${authConfig.mode})`,
+        activeSkill
+          ? `🎭 *Skill:* ${activeSkill.emoji} ${activeSkill.name}`
+          : '🎭 *Skill:* Default persona',
+        `💬 *Messages in memory:* ${msgCount} / ${maxHistory}`,
+        `📌 *Recent window:* ${recentWindow} messages`,
+      ];
+
+      if (recentUserMsgs.length > 0) {
+        lines.push('', '🕐 *Recent topics:*');
+        recentUserMsgs.forEach((msg) => lines.push(`  • ${msg}`));
+      } else {
+        lines.push('', '_No messages yet — start chatting!_');
+      }
+
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    if (text === '/jobs') {
+      logger.info(`[Bot] /jobs command from ${username} (${userId}) in chat ${chatId}`);
+      const jobs = jobManager.getJobsForChat(chatId);
+      if (jobs.length === 0) {
+        await bot.sendMessage(chatId, 'No jobs for this chat.');
+        return;
+      }
+      const lines = ['*Jobs*', ''];
+      for (const job of jobs.slice(0, 15)) {
+        lines.push(job.toSummary());
+      }
+      if (jobs.length > 15) {
+        lines.push(`\n_... and ${jobs.length - 15} more_`);
+      }
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    if (text === '/cancel') {
+      logger.info(`[Bot] /cancel command from ${username} (${userId}) in chat ${chatId}`);
+      const running = jobManager.getRunningJobsForChat(chatId);
+      if (running.length === 0) {
+        logger.debug(`[Bot] /cancel — no running jobs for chat ${chatId}`);
+        await bot.sendMessage(chatId, 'No running jobs to cancel.');
+        return;
+      }
+      if (running.length === 1) {
+        logger.info(`[Bot] /cancel — single job ${running[0].id}, cancelling directly`);
+        const job = jobManager.cancelJob(running[0].id);
+        if (job) {
+          await bot.sendMessage(chatId, `🚫 Cancelled \`${job.id}\` (${job.workerType})`, { parse_mode: 'Markdown' });
+        }
+        return;
+      }
+      // Multiple running — show inline keyboard
+      logger.info(`[Bot] /cancel — ${running.length} running jobs, showing picker`);
+      const buttons = running.map((j) => ([{
+        text: `🚫 ${j.workerType} (${j.id})`,
+        callback_data: `cancel_job:${j.id}`,
+      }]));
+      buttons.push([{ text: '🚫 Cancel All', callback_data: 'cancel_all_jobs' }]);
+      await bot.sendMessage(chatId, `*${running.length} running jobs* — select one to cancel:`, {
+        parse_mode: 'Markdown',
+        reply_markup: { inline_keyboard: buttons },
+      });
+      return;
+    }
+
     if (text === '/help') {
+      const activeSkill = agent.getActiveSkill(chatId);
+      const skillLine = activeSkill
+        ? `\n🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n`
+        : '';
       await bot.sendMessage(chatId, [
         '*KernelBot Commands*',
-        '',
-        '/brain — Show current AI model and switch provider/model',
+        skillLine,
+        '/brain — Switch worker AI model/provider',
+        '/orchestrator — Switch orchestrator AI model/provider',
+        '/claudemodel — Switch Claude Code model',
+        '/claude — Manage Claude Code authentication',
+        '/skills — Browse and activate persona skills',
+        '/skills reset — Clear active skill back to default',
+        '/jobs — List running and recent jobs',
+        '/cancel — Cancel running job(s)',
+        '/auto — Manage recurring automations',
+        '/context — Show all models, auth, and context info',
         '/clean — Clear conversation and start fresh',
         '/history — Show message count in memory',
         '/browse <url> — Browse a website and get a summary',
@@ -263,6 +1130,107 @@ export function startBot(config, agent, conversationManager) {
       return;
     }
 
+    // ── /auto command ──────────────────────────────────────────────
+    if (text === '/auto' || text.startsWith('/auto ')) {
+      logger.info(`[Bot] /auto command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/auto'.length).trim();
+
+      if (!automationManager) {
+        await bot.sendMessage(chatId, 'Automation system not available.');
+        return;
+      }
+
+      // /auto (no args) — list automations
+      if (!args) {
+        const autos = automationManager.listForChat(chatId);
+        if (autos.length === 0) {
+          await bot.sendMessage(chatId, [
+            '⏰ *No automations set up yet.*',
+            '',
+            'Tell me what to automate in natural language, e.g.:',
+            '  "check my server health every hour"',
+            '  "send me a news summary every morning at 9am"',
+            '',
+            'Or use `/auto` subcommands:',
+            '  `/auto pause <id>` — pause an automation',
+            '  `/auto resume <id>` — resume an automation',
+            '  `/auto delete <id>` — delete an automation',
+            '  `/auto run <id>` — trigger immediately',
+          ].join('\n'), { parse_mode: 'Markdown' });
+          return;
+        }
+
+        const lines = ['⏰ *Automations*', ''];
+        for (const auto of autos) {
+          lines.push(auto.toSummary());
+        }
+        lines.push('', '_Use `/auto pause|resume|delete|run <id>` to manage._');
+
+        // Build inline keyboard for quick actions
+        const buttons = autos.map((a) => {
+          const row = [];
+          if (a.enabled) {
+            row.push({ text: `⏸️ Pause ${a.id}`, callback_data: `auto_pause:${a.id}` });
+          } else {
+            row.push({ text: `▶️ Resume ${a.id}`, callback_data: `auto_resume:${a.id}` });
+          }
+          row.push({ text: `🗑️ Delete ${a.id}`, callback_data: `auto_delete:${a.id}` });
+          return row;
+        });
+
+        await bot.sendMessage(chatId, lines.join('\n'), {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        });
+        return;
+      }
+
+      // /auto pause <id>
+      if (args.startsWith('pause ')) {
+        const autoId = args.slice('pause '.length).trim();
+        const auto = automationManager.update(autoId, { enabled: false });
+        await bot.sendMessage(chatId, auto
+          ? `⏸️ Paused automation \`${autoId}\` (${auto.name})`
+          : `Automation \`${autoId}\` not found.`, { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // /auto resume <id>
+      if (args.startsWith('resume ')) {
+        const autoId = args.slice('resume '.length).trim();
+        const auto = automationManager.update(autoId, { enabled: true });
+        await bot.sendMessage(chatId, auto
+          ? `▶️ Resumed automation \`${autoId}\` (${auto.name})`
+          : `Automation \`${autoId}\` not found.`, { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // /auto delete <id>
+      if (args.startsWith('delete ')) {
+        const autoId = args.slice('delete '.length).trim();
+        const deleted = automationManager.delete(autoId);
+        await bot.sendMessage(chatId, deleted
+          ? `🗑️ Deleted automation \`${autoId}\``
+          : `Automation \`${autoId}\` not found.`, { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // /auto run <id> — trigger immediately
+      if (args.startsWith('run ')) {
+        const autoId = args.slice('run '.length).trim();
+        try {
+          await automationManager.runNow(autoId);
+        } catch (err) {
+          await bot.sendMessage(chatId, `Failed: ${err.message}`);
+        }
+        return;
+      }
+
+      // /auto <anything else> — treat as natural language automation request
+      text = `Set up an automation: ${args}`;
+      // Fall through to normal message processing below
+    }
+
     // Web browsing shortcut commands — rewrite as natural language for the agent
     if (text.startsWith('/browse ')) {
       const browseUrl = text.slice('/browse '.length).trim();
@@ -346,22 +1314,24 @@ export function startBot(config, agent, conversationManager) {
         };
 
         const sendPhoto = async (filePath, caption) => {
+          const fileOpts = { contentType: 'image/png' };
           try {
             await bot.sendPhoto(chatId, createReadStream(filePath), {
               caption: caption || '',
               parse_mode: 'Markdown',
-            });
+            }, fileOpts);
           } catch {
             try {
               await bot.sendPhoto(chatId, createReadStream(filePath), {
                 caption: caption || '',
-              });
+              }, fileOpts);
             } catch (err) {
               logger.error(`Failed to send photo: ${err.message}`);
             }
           }
         };
 
+        logger.debug(`[Bot] Sending to orchestrator: chat ${chatId}, text="${mergedText.slice(0, 80)}"`);
         const reply = await agent.processMessage(chatId, mergedText, {
           id: userId,
           username,
@@ -369,6 +1339,7 @@ export function startBot(config, agent, conversationManager) {
 
         clearInterval(typingInterval);
 
+        logger.info(`[Bot] Reply for chat ${chatId}: ${(reply || '').length} chars`);
         const chunks = splitMessage(reply || 'Done.');
         for (const chunk of chunks) {
           try {
@@ -378,9 +1349,21 @@ export function startBot(config, agent, conversationManager) {
             await bot.sendMessage(chatId, chunk);
           }
         }
+
+        // Send voice reply if TTS is available and the reply isn't too short
+        if (ttsService.isAvailable() && reply && reply.length > 5) {
+          try {
+            const audioPath = await ttsService.synthesize(reply);
+            if (audioPath) {
+              await bot.sendVoice(chatId, createReadStream(audioPath));
+            }
+          } catch (err) {
+            logger.warn(`[Bot] TTS voice reply failed: ${err.message}`);
+          }
+        }
       } catch (err) {
         clearInterval(typingInterval);
-        logger.error(`Error processing message: ${err.message}`);
+        logger.error(`[Bot] Error processing message in chat ${chatId}: ${err.message}`);
         await bot.sendMessage(chatId, `Error: ${err.message}`);
       }
     });