kernelbot 1.0.28 → 1.0.32

package/src/bot.js

@@ -12,6 +12,9 @@ import {
   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];
@@ -50,12 +53,19 @@ class ChatQueue {
   }
 }
 
-export function startBot(config, agent, conversationManager, jobManager, automationManager) {
+export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
+  const { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge } = lifeDeps;
   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();
 
@@ -68,6 +78,26 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   // 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: 'life', description: 'Inner life engine status and control' },
+    { command: 'journal', description: 'View today\'s journal or a past date' },
+    { command: 'memories', description: 'View recent memories or search' },
+    { command: 'evolution', description: 'Self-evolution status, history, and lessons' },
+    { 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
@@ -100,7 +130,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
               });
               return edited.message_id;
             } catch {
-              return opts.editMessageId;
+              // Edit failed — fall through to send new message
             }
           }
         }
@@ -142,6 +172,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   // 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();
 
@@ -451,6 +487,140 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         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(`[Bot] Callback query error for "${data}" in chat ${chatId}: ${err.message}`);
@@ -546,6 +716,32 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       }
     }
 
+    // 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();
@@ -582,6 +778,60 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       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,
+        `🔐 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);
@@ -640,6 +890,78 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       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);
@@ -693,6 +1015,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
     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);
@@ -711,7 +1036,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       const lines = [
         '📋 *Conversation Context*',
         '',
-        `🧠 *Brain:* ${info.providerName} / ${info.modelLabel}`,
+        `🎛️ *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',
@@ -778,6 +1105,296 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── /life command ──────────────────────────────────────────────
+    if (text === '/life' || text.startsWith('/life ')) {
+      logger.info(`[Bot] /life command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/life'.length).trim();
+
+      if (!lifeEngine) {
+        await bot.sendMessage(chatId, 'Life engine is not available.');
+        return;
+      }
+
+      if (args === 'pause') {
+        lifeEngine.pause();
+        await bot.sendMessage(chatId, '⏸️ Inner life paused. Use `/life resume` to restart.', { parse_mode: 'Markdown' });
+        return;
+      }
+      if (args === 'resume') {
+        lifeEngine.resume();
+        await bot.sendMessage(chatId, '▶️ Inner life resumed!');
+        return;
+      }
+      if (args.startsWith('trigger')) {
+        const activityType = args.split(/\s+/)[1] || null;
+        const validTypes = ['think', 'browse', 'journal', 'create', 'self_code', 'code_review', 'reflect'];
+        if (activityType && !validTypes.includes(activityType)) {
+          await bot.sendMessage(chatId, `Unknown activity type. Available: ${validTypes.join(', ')}`);
+          return;
+        }
+        await bot.sendMessage(chatId, `⚡ Triggering ${activityType || 'random'} activity...`);
+        lifeEngine.triggerNow(activityType).catch(err => {
+          logger.error(`[Bot] Life trigger failed: ${err.message}`);
+        });
+        return;
+      }
+      if (args === 'review') {
+        if (evolutionTracker) {
+          const active = evolutionTracker.getActiveProposal();
+          const openPRs = evolutionTracker.getPRsToCheck();
+          const lines = ['*Evolution Status*', ''];
+          if (active) {
+            lines.push(`Active: \`${active.id}\` — ${active.status}`);
+            lines.push(`  ${(active.triggerContext || '').slice(0, 150)}`);
+          } else {
+            lines.push('_No active proposals._');
+          }
+          if (openPRs.length > 0) {
+            lines.push('', '*Open PRs:*');
+            for (const p of openPRs) {
+              lines.push(`  • PR #${p.prNumber}: ${p.prUrl || 'no URL'}`);
+            }
+          }
+          lines.push('', '_Use `/evolution` for full evolution status._');
+          await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        } else {
+          await bot.sendMessage(chatId, 'Evolution system not available. Use `/evolution` for details.', { parse_mode: 'Markdown' });
+        }
+        return;
+      }
+
+      // Default: show status
+      const status = lifeEngine.getStatus();
+      const lines = [
+        '🌱 *Inner Life*',
+        '',
+        `*Status:* ${status.paused ? '⏸️ Paused' : status.status === 'active' ? '🟢 Active' : '⚪ Idle'}`,
+        `*Total activities:* ${status.totalActivities}`,
+        `*Last activity:* ${status.lastActivity || 'none'} (${status.lastActivityAgo})`,
+        `*Last wake-up:* ${status.lastWakeUpAgo}`,
+        '',
+        '*Activity counts:*',
+        `  💭 Think: ${status.activityCounts.think || 0}`,
+        `  🌐 Browse: ${status.activityCounts.browse || 0}`,
+        `  📓 Journal: ${status.activityCounts.journal || 0}`,
+        `  🎨 Create: ${status.activityCounts.create || 0}`,
+        `  🔧 Self-code: ${status.activityCounts.self_code || 0}`,
+        `  🔍 Code review: ${status.activityCounts.code_review || 0}`,
+        `  🪞 Reflect: ${status.activityCounts.reflect || 0}`,
+        '',
+        '_Commands:_',
+        '`/life pause` — Pause activities',
+        '`/life resume` — Resume activities',
+        '`/life trigger [think|browse|journal|create|self_code|code_review|reflect]` — Trigger now',
+      ];
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /journal command ─────────────────────────────────────────
+    if (text === '/journal' || text.startsWith('/journal ')) {
+      logger.info(`[Bot] /journal command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!journalManager) {
+        await bot.sendMessage(chatId, 'Journal system is not available.');
+        return;
+      }
+
+      const args = text.slice('/journal'.length).trim();
+
+      if (args && /^\d{4}-\d{2}-\d{2}$/.test(args)) {
+        const entry = journalManager.getEntry(args);
+        if (!entry) {
+          await bot.sendMessage(chatId, `No journal entry for ${args}.`);
+          return;
+        }
+        const chunks = splitMessage(entry);
+        for (const chunk of chunks) {
+          try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+          catch { await bot.sendMessage(chatId, chunk); }
+        }
+        return;
+      }
+
+      if (args === 'list') {
+        const dates = journalManager.list(15);
+        if (dates.length === 0) {
+          await bot.sendMessage(chatId, 'No journal entries yet.');
+          return;
+        }
+        const lines = ['📓 *Journal Entries*', '', ...dates.map(d => `  • \`${d}\``)];
+        lines.push('', '_Use `/journal YYYY-MM-DD` to read an entry._');
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show today's journal
+      const today = journalManager.getToday();
+      if (!today) {
+        await bot.sendMessage(chatId, '📓 No journal entries today yet.\n\n_Use `/journal list` to see past entries._', { parse_mode: 'Markdown' });
+        return;
+      }
+      const chunks = splitMessage(today);
+      for (const chunk of chunks) {
+        try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+        catch { await bot.sendMessage(chatId, chunk); }
+      }
+      return;
+    }
+
+    // ── /memories command ────────────────────────────────────────
+    if (text === '/memories' || text.startsWith('/memories ')) {
+      logger.info(`[Bot] /memories command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!memoryManager) {
+        await bot.sendMessage(chatId, 'Memory system is not available.');
+        return;
+      }
+
+      const args = text.slice('/memories'.length).trim();
+
+      if (args.startsWith('about ')) {
+        const query = args.slice('about '.length).trim();
+        const results = memoryManager.searchEpisodic(query, 10);
+        if (results.length === 0) {
+          await bot.sendMessage(chatId, `No memories matching "${query}".`);
+          return;
+        }
+        const lines = [`🧠 *Memories about "${query}"*`, ''];
+        for (const m of results) {
+          const date = new Date(m.timestamp).toLocaleDateString();
+          lines.push(`• ${m.summary} _(${date}, importance: ${m.importance})_`);
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show last 10 memories
+      const recent = memoryManager.getRecentEpisodic(168, 10); // last 7 days
+      if (recent.length === 0) {
+        await bot.sendMessage(chatId, '🧠 No memories yet.');
+        return;
+      }
+      const lines = ['🧠 *Recent Memories*', ''];
+      for (const m of recent) {
+        const ago = Math.round((Date.now() - m.timestamp) / 60000);
+        const timeLabel = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
+        const icon = { interaction: '💬', discovery: '🔍', thought: '💭', creation: '🎨' }[m.type] || '•';
+        lines.push(`${icon} ${m.summary} _(${timeLabel})_`);
+      }
+      lines.push('', '_Use `/memories about <topic>` to search._');
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /evolution command ──────────────────────────────────────────
+    if (text === '/evolution' || text.startsWith('/evolution ')) {
+      logger.info(`[Bot] /evolution command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/evolution'.length).trim();
+
+      if (!evolutionTracker) {
+        await bot.sendMessage(chatId, 'Evolution system is not available.');
+        return;
+      }
+
+      if (args === 'history') {
+        const proposals = evolutionTracker.getRecentProposals(10);
+        if (proposals.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution proposals yet.');
+          return;
+        }
+        const lines = ['*Evolution History*', ''];
+        for (const p of proposals.reverse()) {
+          const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄', merged: '✅', rejected: '❌', failed: '💥' }[p.status] || '•';
+          const age = Math.round((Date.now() - p.createdAt) / 3600_000);
+          const ageLabel = age < 24 ? `${age}h ago` : `${Math.round(age / 24)}d ago`;
+          lines.push(`${statusIcon} \`${p.id}\` — ${p.status} (${ageLabel})`);
+          lines.push(`  ${(p.triggerContext || '').slice(0, 100)}`);
+          if (p.prUrl) lines.push(`  PR: ${p.prUrl}`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'lessons') {
+        const lessons = evolutionTracker.getRecentLessons(15);
+        if (lessons.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution lessons learned yet.');
+          return;
+        }
+        const lines = ['*Evolution Lessons*', ''];
+        for (const l of lessons.reverse()) {
+          lines.push(`• [${l.category}] ${l.lesson}`);
+          if (l.fromProposal) lines.push(`  _from ${l.fromProposal}_`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'trigger') {
+        if (!lifeEngine) {
+          await bot.sendMessage(chatId, 'Life engine is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '⚡ Triggering evolution cycle...');
+        lifeEngine.triggerNow('self_code').catch(err => {
+          logger.error(`[Bot] Evolution trigger failed: ${err.message}`);
+        });
+        return;
+      }
+
+      if (args === 'scan') {
+        if (!codebaseKnowledge) {
+          await bot.sendMessage(chatId, 'Codebase knowledge is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '🔍 Scanning codebase...');
+        codebaseKnowledge.scanChanged().then(count => {
+          bot.sendMessage(chatId, `✅ Scanned ${count} changed files.`).catch(() => {});
+        }).catch(err => {
+          bot.sendMessage(chatId, `Failed: ${err.message}`).catch(() => {});
+        });
+        return;
+      }
+
+      // Default: show status
+      const active = evolutionTracker.getActiveProposal();
+      const stats = evolutionTracker.getStats();
+      const openPRs = evolutionTracker.getPRsToCheck();
+
+      const lines = [
+        '🧬 *Self-Evolution*',
+        '',
+        `*Stats:* ${stats.totalProposals} total | ${stats.merged} merged | ${stats.rejected} rejected | ${stats.failed} failed`,
+        `*Success rate:* ${stats.successRate}%`,
+        `*Open PRs:* ${openPRs.length}`,
+      ];
+
+      if (active) {
+        const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄' }[active.status] || '•';
+        lines.push('');
+        lines.push(`*Active proposal:* ${statusIcon} \`${active.id}\` — ${active.status}`);
+        lines.push(`  ${(active.triggerContext || '').slice(0, 120)}`);
+        if (active.prUrl) lines.push(`  PR: ${active.prUrl}`);
+      } else {
+        lines.push('', '_No active proposal_');
+      }
+
+      lines.push(
+        '',
+        '_Commands:_',
+        '`/evolution history` — Recent proposals',
+        '`/evolution lessons` — Learned lessons',
+        '`/evolution trigger` — Trigger evolution now',
+        '`/evolution scan` — Scan codebase',
+      );
+
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
     if (text === '/help') {
       const activeSkill = agent.getActiveSkill(chatId);
       const skillLine = activeSkill
@@ -786,13 +1403,20 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       await bot.sendMessage(chatId, [
         '*KernelBot Commands*',
         skillLine,
-        '/brain — Show current AI model and switch provider/model',
+        '/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 current conversation context and brain info',
+        '/life — Inner life engine status & control',
+        '/journal — View today\'s journal or a past date',
+        '/memories — View recent memories or search',
+        '/evolution — Self-evolution status, history, lessons',
+        '/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',
@@ -968,12 +1592,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
                 });
                 return edited.message_id;
               } catch {
-                return opts.editMessageId;
+                // Edit failed — fall through to send new message
               }
             }
           }
 
-          // Send new message(s)
+          // Send new message(s) — also reached when edit fails
           const parts = splitMessage(update);
           let lastMsgId = null;
           for (const part of parts) {
@@ -1024,6 +1648,18 @@ export function startBot(config, agent, conversationManager, jobManager, automat
             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(`[Bot] Error processing message in chat ${chatId}: ${err.message}`);