kernelbot 1.0.36 → 1.0.38

package/src/bot.js

@@ -16,6 +16,8 @@ import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
 import { isQuietHours } from './utils/timeUtils.js';
+import { CharacterBuilder } from './characters/builder.js';
+import { LifeEngine } from './life/engine.js';
 
 /**
  * Simulate a human-like typing delay based on response length.
@@ -120,8 +122,12 @@ function createOnUpdate(bot, chatId) {
         lastMsgId = sent.message_id;
       } catch (mdErr) {
         logger.debug(`[Bot] Markdown send failed for chat ${chatId}, falling back to plain: ${mdErr.message}`);
-        const sent = await bot.sendMessage(chatId, part);
-        lastMsgId = sent.message_id;
+        try {
+          const sent = await bot.sendMessage(chatId, part);
+          lastMsgId = sent.message_id;
+        } catch (plainErr) {
+          logger.error(`[Bot] Plain-text send also failed for chat ${chatId}: ${plainErr.message}`);
+        }
       }
     }
     return lastMsgId;
@@ -156,11 +162,16 @@ function createSendPhoto(bot, chatId, logger) {
  * Create a sendReaction callback for reacting to messages with emoji.
  */
 function createSendReaction(bot) {
+  const logger = getLogger();
   return async (targetChatId, targetMsgId, emoji, isBig = false) => {
-    await bot.setMessageReaction(targetChatId, targetMsgId, {
-      reaction: [{ type: 'emoji', emoji }],
-      is_big: isBig,
-    });
+    try {
+      await bot.setMessageReaction(targetChatId, targetMsgId, {
+        reaction: [{ type: 'emoji', emoji }],
+        is_big: isBig,
+      });
+    } catch (err) {
+      logger.debug(`[Bot] Failed to set reaction for msg ${targetMsgId} in chat ${targetChatId}: ${err.message}`);
+    }
   };
 }
 
@@ -196,7 +207,7 @@ class ChatQueue {
 }
 
 export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
-  const { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge } = lifeDeps;
+  let { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge, characterManager, dashboardHandle, dashboardDeps } = lifeDeps;
   const logger = getLogger();
   const bot = new TelegramBot(config.telegram.bot_token, {
     polling: {
@@ -214,6 +225,52 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   if (ttsService.isAvailable()) logger.info('[Bot] TTS service enabled (ElevenLabs)');
   if (sttService.isAvailable()) logger.info('[Bot] STT service enabled');
 
+  /**
+   * Rebuild the life engine for a different character.
+   * Stops the current engine, creates a new one with scoped managers, and starts it.
+   */
+  function rebuildLifeEngine(charCtx) {
+    if (lifeEngine) {
+      lifeEngine.stop();
+    }
+
+    // Update module-level manager refs so other bot.js code uses the right ones
+    memoryManager = charCtx.memoryManager;
+    journalManager = charCtx.journalManager;
+    shareQueue = charCtx.shareQueue;
+    evolutionTracker = charCtx.evolutionTracker;
+
+    // Switch conversation file to the new character's conversations.json
+    conversationManager.switchFile(charCtx.conversationFilePath);
+
+    const lifeEnabled = config.life?.enabled !== false;
+    if (!lifeEnabled) {
+      lifeEngine = null;
+      return;
+    }
+
+    lifeEngine = new LifeEngine({
+      config,
+      agent,
+      memoryManager: charCtx.memoryManager,
+      journalManager: charCtx.journalManager,
+      shareQueue: charCtx.shareQueue,
+      evolutionTracker: charCtx.evolutionTracker,
+      codebaseKnowledge,
+      selfManager: charCtx.selfManager,
+      basePath: charCtx.lifeBasePath,
+      characterId: charCtx.characterId,
+    });
+
+    lifeEngine.wakeUp().then(() => {
+      lifeEngine.start();
+      logger.info(`[Bot] Life engine rebuilt for character: ${charCtx.characterId}`);
+    }).catch(err => {
+      logger.error(`[Bot] Life engine wake-up failed: ${err.message}`);
+      lifeEngine.start();
+    });
+  }
+
   // Per-chat message batching: chatId -> { messages[], timer, resolve }
   const chatBatches = new Map();
 
@@ -228,6 +285,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
   // Register commands in Telegram's menu button
   bot.setMyCommands([
+    { command: 'character', description: 'Switch or manage characters' },
     { command: 'brain', description: 'Switch worker AI model/provider' },
     { command: 'orchestrator', description: 'Switch orchestrator AI model/provider' },
     { command: 'claudemodel', description: 'Switch Claude Code model' },
@@ -240,6 +298,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     { 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: 'linkedin', description: 'Link/unlink LinkedIn account' },
+    { command: 'x', description: 'Link/unlink X (Twitter) account' },
+    { command: 'dashboard', description: 'Start/stop the monitoring dashboard' },
     { 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' },
@@ -283,6 +344,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   // Track pending custom skill creation: chatId -> { step: 'name' | 'prompt', name?: string }
   const pendingCustomSkill = new Map();
 
+  // Track pending custom character build: chatId -> { answers: {}, step: number }
+  const pendingCharacterBuild = new Map();
+
   // Handle inline keyboard callbacks for /brain
   bot.on('callback_query', async (query) => {
     const chatId = query.message.chat.id;
@@ -730,6 +794,230 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           chat_id: chatId, message_id: query.message.message_id,
         });
         await bot.answerCallbackQuery(query.id);
+
+      // ── Character callbacks ────────────────────────────────────────
+      } else if (data.startsWith('char_select:')) {
+        const charId = data.slice('char_select:'.length);
+        if (!characterManager) {
+          await bot.answerCallbackQuery(query.id, { text: 'Character system not available' });
+          return;
+        }
+        const character = characterManager.getCharacter(charId);
+        if (!character) {
+          await bot.answerCallbackQuery(query.id, { text: 'Character not found' });
+          return;
+        }
+        const activeId = agent.getActiveCharacterInfo()?.id;
+        const isActive = activeId === charId;
+        const buttons = [];
+        if (!isActive) {
+          buttons.push([{ text: `Switch to ${character.emoji} ${character.name}`, callback_data: `char_confirm:${charId}` }]);
+        }
+        buttons.push([
+          { text: '« Back', callback_data: 'char_back' },
+          { text: 'Cancel', callback_data: 'char_cancel' },
+        ]);
+
+        const artBlock = character.asciiArt ? `\n\`\`\`\n${character.asciiArt}\n\`\`\`\n` : '\n';
+        await bot.editMessageText(
+          `${character.emoji} *${character.name}*\n_${character.origin || 'Original'}_${artBlock}\n"${character.tagline}"\n\n*Age:* ${character.age}\n${isActive ? '_(Currently active)_' : ''}`,
+          {
+            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('char_confirm:')) {
+        const charId = data.slice('char_confirm:'.length);
+        if (!characterManager) {
+          await bot.answerCallbackQuery(query.id, { text: 'Character system not available' });
+          return;
+        }
+
+        await bot.editMessageText(
+          `Switching character...`,
+          { chat_id: chatId, message_id: query.message.message_id },
+        );
+
+        try {
+          const charCtx = agent.switchCharacter(charId);
+
+          // Rebuild life engine with new character's scoped managers
+          rebuildLifeEngine(charCtx);
+
+          const character = characterManager.getCharacter(charId);
+          logger.info(`[Bot] Character switched to ${character.name} (${charId})`);
+
+          await bot.editMessageText(
+            `${character.emoji} *${character.name}* is now active!\n\n"${character.tagline}"`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        } catch (err) {
+          logger.error(`[Bot] Character switch failed: ${err.message}`);
+          await bot.editMessageText(
+            `Failed to switch character: ${err.message}`,
+            { chat_id: chatId, message_id: query.message.message_id },
+          );
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'char_custom') {
+        pendingCharacterBuild.set(chatId, { answers: {}, step: 0 });
+        const builder = new CharacterBuilder(agent.orchestratorProvider);
+        const nextQ = builder.getNextQuestion({});
+        if (nextQ) {
+          await bot.editMessageText(
+            `*Custom Character Builder* (1/${builder.getTotalQuestions()})\n\n${nextQ.question}\n\n_Examples: ${nextQ.examples}_\n\nSend *cancel* to abort.`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('char_delete:')) {
+        const charId = data.slice('char_delete:'.length);
+        if (!characterManager) {
+          await bot.answerCallbackQuery(query.id, { text: 'Character system not available' });
+          return;
+        }
+        const buttons = [
+          [{ text: `Yes, delete`, callback_data: `char_delete_confirm:${charId}` }],
+          [{ text: 'Cancel', callback_data: 'char_back' }],
+        ];
+        const character = characterManager.getCharacter(charId);
+        await bot.editMessageText(
+          `Are you sure you want to delete *${character?.name || charId}*?\n\nThis will remove all their memories, journals, and conversation history.`,
+          {
+            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('char_delete_confirm:')) {
+        const charId = data.slice('char_delete_confirm:'.length);
+        try {
+          characterManager.removeCharacter(charId);
+          await bot.editMessageText(`Character deleted.`, {
+            chat_id: chatId, message_id: query.message.message_id,
+          });
+        } catch (err) {
+          await bot.editMessageText(`Cannot delete: ${err.message}`, {
+            chat_id: chatId, message_id: query.message.message_id,
+          });
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'char_back') {
+        // Re-show character gallery
+        if (!characterManager) {
+          await bot.answerCallbackQuery(query.id, { text: 'Character system not available' });
+          return;
+        }
+        const characters = characterManager.listCharacters();
+        const activeInfo = agent.getActiveCharacterInfo();
+        const buttons = [];
+        const row1 = [], row2 = [];
+        for (const c of characters) {
+          const label = `${c.emoji} ${c.name}${activeInfo?.id === c.id ? ' \u2713' : ''}`;
+          const btn = { text: label, callback_data: `char_select:${c.id}` };
+          if (row1.length < 3) row1.push(btn);
+          else row2.push(btn);
+        }
+        if (row1.length > 0) buttons.push(row1);
+        if (row2.length > 0) buttons.push(row2);
+
+        // Custom character + delete buttons
+        const mgmtRow = [{ text: 'Build Custom', callback_data: 'char_custom' }];
+        const customChars = characters.filter(c => c.type === 'custom');
+        if (customChars.length > 0) {
+          mgmtRow.push({ text: 'Delete Custom', callback_data: 'char_delete_pick' });
+        }
+        buttons.push(mgmtRow);
+        buttons.push([{ text: 'Cancel', callback_data: 'char_cancel' }]);
+
+        await bot.editMessageText(
+          `*Active:* ${activeInfo?.emoji || ''} ${activeInfo?.name || 'None'}\n_"${activeInfo?.tagline || ''}"_\n\nSelect a character:`,
+          {
+            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 === 'char_delete_pick') {
+        const customChars = characterManager.listCharacters().filter(c => c.type === 'custom');
+        if (customChars.length === 0) {
+          await bot.answerCallbackQuery(query.id, { text: 'No custom characters' });
+          return;
+        }
+        const buttons = customChars.map(c => ([{
+          text: `${c.emoji} ${c.name}`,
+          callback_data: `char_delete:${c.id}`,
+        }]));
+        buttons.push([{ text: '« Back', callback_data: 'char_back' }]);
+        await bot.editMessageText('Select a custom character to delete:', {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+          reply_markup: { inline_keyboard: buttons },
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'char_cancel') {
+        pendingCharacterBuild.delete(chatId);
+        await bot.editMessageText('Character selection dismissed.', {
+          chat_id: chatId, message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      // ── Onboarding callbacks ───────────────────────────────────────
+      } else if (data.startsWith('onboard_select:')) {
+        const charId = data.slice('onboard_select:'.length);
+        if (!characterManager) {
+          await bot.answerCallbackQuery(query.id, { text: 'Not available' });
+          return;
+        }
+
+        characterManager.completeOnboarding(charId);
+        const charCtx = agent.loadCharacter(charId);
+        const character = characterManager.getCharacter(charId);
+
+        // Start life engine for the selected character
+        rebuildLifeEngine(charCtx);
+
+        logger.info(`[Bot] Onboarding complete — character: ${character.name} (${charId})`);
+
+        await bot.editMessageText(
+          `${character.emoji} *${character.name}* activated!\n\n"${character.tagline}"\n\nSend me a message to start chatting.`,
+          { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+        );
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'onboard_custom') {
+        // Start custom builder during onboarding — install builtins first
+        if (characterManager?.needsOnboarding) {
+          // Complete onboarding with kernel as default, then build custom
+          characterManager.completeOnboarding('kernel');
+          const kernelCtx = agent.loadCharacter('kernel');
+          rebuildLifeEngine(kernelCtx);
+        }
+
+        pendingCharacterBuild.set(chatId, { answers: {}, step: 0 });
+        const builder = new CharacterBuilder(agent.orchestratorProvider);
+        const nextQ = builder.getNextQuestion({});
+        if (nextQ) {
+          await bot.editMessageText(
+            `*Custom Character Builder* (1/${builder.getTotalQuestions()})\n\n${nextQ.question}\n\n_Examples: ${nextQ.examples}_\n\nSend *cancel* to abort.`,
+            { chat_id: chatId, message_id: query.message.message_id, parse_mode: 'Markdown' },
+          );
+        }
+        await bot.answerCallbackQuery(query.id);
       }
     } catch (err) {
       logger.error(`[Bot] Callback query error for "${data}" in chat ${chatId}: ${err.message}`);
@@ -797,6 +1085,38 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── Character onboarding ─────────────────────────────────────
+    // On first-ever message, show character selection gallery
+    if (characterManager?.needsOnboarding) {
+      logger.info(`[Bot] First message from ${username} — showing character onboarding`);
+
+      const characters = characterManager.listCharacters();
+      const buttons = [];
+      const row1 = [], row2 = [];
+      for (const c of characters) {
+        const btn = { text: `${c.emoji} ${c.name}`, callback_data: `onboard_select:${c.id}` };
+        if (row1.length < 3) row1.push(btn);
+        else row2.push(btn);
+      }
+      if (row1.length > 0) buttons.push(row1);
+      if (row2.length > 0) buttons.push(row2);
+      buttons.push([{ text: 'Build Custom', callback_data: 'onboard_custom' }]);
+
+      await bot.sendMessage(chatId, [
+        '*Choose Your Character*',
+        '',
+        'Pick who you want me to be. Each character has their own personality, memories, and story that evolves with you.',
+        '',
+        ...characters.map(c => `${c.emoji} *${c.name}* — _${c.tagline}_`),
+        '',
+        'Select below:',
+      ].join('\n'), {
+        parse_mode: 'Markdown',
+        reply_markup: { inline_keyboard: buttons },
+      });
+      return;
+    }
+
     // Handle file upload for pending custom skill prompt step
     if (msg.document && pendingCustomSkill.has(chatId)) {
       const pending = pendingCustomSkill.get(chatId);
@@ -1015,7 +1335,111 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       }
     }
 
+    // Handle pending custom character build
+    if (pendingCharacterBuild.has(chatId)) {
+      const pending = pendingCharacterBuild.get(chatId);
+
+      if (text.toLowerCase() === 'cancel') {
+        pendingCharacterBuild.delete(chatId);
+        await bot.sendMessage(chatId, 'Character creation cancelled.');
+        return;
+      }
+
+      const builder = new CharacterBuilder(agent.orchestratorProvider);
+      const nextQ = builder.getNextQuestion(pending.answers);
+      if (nextQ) {
+        pending.answers[nextQ.id] = text;
+        pending.step++;
+        pendingCharacterBuild.set(chatId, pending);
+
+        const followUp = builder.getNextQuestion(pending.answers);
+        if (followUp) {
+          const { answered, total } = builder.getProgress(pending.answers);
+          await bot.sendMessage(
+            chatId,
+            `*Custom Character Builder* (${answered + 1}/${total})\n\n${followUp.question}\n\n_Examples: ${followUp.examples}_`,
+            { parse_mode: 'Markdown' },
+          );
+        } else {
+          // All questions answered — generate character
+          pendingCharacterBuild.delete(chatId);
+          await bot.sendMessage(chatId, 'Creating your character...');
+
+          try {
+            const result = await builder.generateCharacter(pending.answers);
+            const profile = characterManager.addCharacter(
+              {
+                id: result.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''),
+                type: 'custom',
+                name: result.name,
+                origin: 'Custom',
+                age: result.age,
+                emoji: result.emoji,
+                tagline: result.tagline,
+              },
+              result.personaMd,
+              result.selfDefaults,
+            );
+
+            // Auto-switch to the new character and rebuild life engine
+            const charCtx = agent.switchCharacter(profile.id);
+            rebuildLifeEngine(charCtx);
+
+            await bot.sendMessage(
+              chatId,
+              `${profile.emoji} *${profile.name}* has been created and activated!\n\n"${profile.tagline}"\n\n_Use /character to switch between characters._`,
+              { parse_mode: 'Markdown' },
+            );
+            logger.info(`[Bot] Custom character created: ${profile.name} (${profile.id}) by ${username}`);
+          } catch (err) {
+            logger.error(`[Bot] Character generation failed: ${err.message}`);
+            await bot.sendMessage(chatId, `Failed to create character: ${err.message}\n\nUse /character to try again.`);
+          }
+        }
+      }
+      return;
+    }
+
     // Handle commands — these bypass batching entirely
+    if (text === '/character') {
+      logger.info(`[Bot] /character command from ${username} (${userId}) in chat ${chatId}`);
+      if (!characterManager) {
+        await bot.sendMessage(chatId, 'Character system not available.');
+        return;
+      }
+      const characters = characterManager.listCharacters();
+      const activeInfo = agent.getActiveCharacterInfo();
+      const buttons = [];
+      const row1 = [], row2 = [];
+      for (const c of characters) {
+        const label = `${c.emoji} ${c.name}${activeInfo?.id === c.id ? ' \u2713' : ''}`;
+        const btn = { text: label, callback_data: `char_select:${c.id}` };
+        if (row1.length < 3) row1.push(btn);
+        else row2.push(btn);
+      }
+      if (row1.length > 0) buttons.push(row1);
+      if (row2.length > 0) buttons.push(row2);
+
+      // Custom character + delete buttons
+      const mgmtRow = [{ text: 'Build Custom', callback_data: 'char_custom' }];
+      const customChars = characters.filter(c => c.type === 'custom');
+      if (customChars.length > 0) {
+        mgmtRow.push({ text: 'Delete Custom', callback_data: 'char_delete_pick' });
+      }
+      buttons.push(mgmtRow);
+      buttons.push([{ text: 'Cancel', callback_data: 'char_cancel' }]);
+
+      await bot.sendMessage(
+        chatId,
+        `*Active:* ${activeInfo?.emoji || ''} ${activeInfo?.name || 'None'}\n_"${activeInfo?.tagline || ''}"_\n\nSelect a character:`,
+        {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        },
+      );
+      return;
+    }
+
     if (text === '/brain') {
       logger.info(`[Bot] /brain command from ${username} (${userId}) in chat ${chatId}`);
       const info = agent.getBrainInfo();
@@ -1148,14 +1572,14 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     }
 
     if (text === '/clean' || text === '/clear' || text === '/reset') {
-      conversationManager.clear(chatId);
+      agent.clearConversation(chatId);
       logger.info(`Conversation cleared for chat ${chatId} by ${username}`);
       await bot.sendMessage(chatId, '🧹 Conversation cleared. Starting fresh.');
       return;
     }
 
     if (text === '/history') {
-      const count = conversationManager.getMessageCount(chatId);
+      const count = agent.getMessageCount(chatId);
       await bot.sendMessage(chatId, `📝 This chat has *${count}* messages in memory.`, { parse_mode: 'Markdown' });
       return;
     }
@@ -1166,8 +1590,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       const ccInfo = agent.getClaudeCodeInfo();
       const authConfig = agent.getClaudeAuthConfig();
       const activeSkill = agent.getActiveSkill(chatId);
-      const msgCount = conversationManager.getMessageCount(chatId);
-      const history = conversationManager.getHistory(chatId);
+      const msgCount = agent.getMessageCount(chatId);
+      const history = agent.getConversationHistory(chatId);
       const maxHistory = conversationManager.maxHistory;
       const recentWindow = conversationManager.recentWindow;
 
@@ -1180,9 +1604,14 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           return txt.length > 80 ? txt.slice(0, 80) + '…' : txt;
         });
 
+      const activeChar = agent.getActiveCharacterInfo();
+
       const lines = [
         '📋 *Conversation Context*',
         '',
+        activeChar
+          ? `${activeChar.emoji} *Character:* ${activeChar.name}`
+          : '',
         `🎛️ *Orchestrator:* ${orchInfo.providerName} / ${orchInfo.modelLabel}`,
         `🧠 *Brain (Workers):* ${info.providerName} / ${info.modelLabel}`,
         `💻 *Claude Code:* ${ccInfo.modelLabel} (auth: ${authConfig.mode})`,
@@ -1191,7 +1620,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           : '🎭 *Skill:* Default persona',
         `💬 *Messages in memory:* ${msgCount} / ${maxHistory}`,
         `📌 *Recent window:* ${recentWindow} messages`,
-      ];
+      ].filter(Boolean);
 
       if (recentUserMsgs.length > 0) {
         lines.push('', '🕐 *Recent topics:*');
@@ -1338,6 +1767,63 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── /dashboard command ────────────────────────────────────────
+    if (text === '/dashboard' || text.startsWith('/dashboard ')) {
+      logger.info(`[Bot] /dashboard command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/dashboard'.length).trim();
+      const port = config.dashboard?.port || 3000;
+
+      if (args === 'start') {
+        if (dashboardHandle) {
+          await bot.sendMessage(chatId, `Dashboard already running at http://localhost:${port}`);
+          return;
+        }
+        try {
+          const { startDashboard } = await import('./dashboard/server.js');
+          dashboardHandle = startDashboard({ port, ...dashboardDeps });
+          logger.info(`[Dashboard] Started via /dashboard command on port ${port}`);
+          await bot.sendMessage(chatId, `🖥️ Dashboard started at http://localhost:${port}`);
+        } catch (err) {
+          logger.error(`[Dashboard] Failed to start: ${err.message}`);
+          await bot.sendMessage(chatId, `Failed to start dashboard: ${err.message}`);
+        }
+        return;
+      }
+
+      if (args === 'stop') {
+        if (!dashboardHandle) {
+          await bot.sendMessage(chatId, 'Dashboard is not running.');
+          return;
+        }
+        try {
+          dashboardHandle.stop();
+          dashboardHandle = null;
+          logger.info('[Dashboard] Stopped via /dashboard command');
+          await bot.sendMessage(chatId, '🛑 Dashboard stopped.');
+        } catch (err) {
+          logger.error(`[Dashboard] Failed to stop: ${err.message}`);
+          await bot.sendMessage(chatId, `Failed to stop dashboard: ${err.message}`);
+        }
+        return;
+      }
+
+      // Default: show status
+      const running = !!dashboardHandle;
+      const lines = [
+        '🖥️ *Dashboard*',
+        '',
+        `*Status:* ${running ? '🟢 Running' : '⚪ Stopped'}`,
+        `*Port:* ${port}`,
+        running ? `*URL:* http://localhost:${port}` : '',
+        '',
+        '_Commands:_',
+        '`/dashboard start` — Start the dashboard',
+        '`/dashboard stop` — Stop the dashboard',
+      ].filter(Boolean);
+      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}`);
@@ -1542,6 +2028,228 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── /linkedin command ───────────────────────────────────────────
+    if (text === '/linkedin' || text.startsWith('/linkedin ')) {
+      logger.info(`[Bot] /linkedin command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/linkedin'.length).trim();
+
+      // /linkedin link <token> — validate token and save
+      if (args.startsWith('link')) {
+        const token = args.slice('link'.length).trim();
+        if (!token) {
+          await bot.sendMessage(chatId, [
+            '🔗 *Connect your LinkedIn account*',
+            '',
+            '1. Go to https://www.linkedin.com/developers/tools/oauth/token-generator',
+            '2. Select your app, pick scopes: `openid`, `profile`, `email`, `w_member_social`',
+            '3. Authorize and copy the token',
+            '4. Run: `/linkedin link <your-token>`',
+          ].join('\n'), { parse_mode: 'Markdown' });
+          return;
+        }
+
+        await bot.sendMessage(chatId, '⏳ Validating token...');
+
+        try {
+          // Try /v2/userinfo (requires "Sign in with LinkedIn" product → openid+profile scopes)
+          const res = await fetch('https://api.linkedin.com/v2/userinfo', {
+            headers: { 'Authorization': `Bearer ${token}` },
+          });
+
+          const { saveCredential } = await import('./utils/config.js');
+
+          if (res.ok) {
+            const profile = await res.json();
+            const personUrn = `urn:li:person:${profile.sub}`;
+
+            saveCredential(config, 'LINKEDIN_ACCESS_TOKEN', token);
+            saveCredential(config, 'LINKEDIN_PERSON_URN', personUrn);
+
+            await bot.sendMessage(chatId, [
+              '✅ *LinkedIn connected!*',
+              '',
+              `👤 *${profile.name}*`,
+              profile.email ? `📧 ${profile.email}` : '',
+              '',
+              'You can now ask me to post on LinkedIn, view your posts, comment, and more.',
+            ].filter(Boolean).join('\n'), { parse_mode: 'Markdown' });
+          } else if (res.status === 401) {
+            throw new Error('Invalid or expired token.');
+          } else {
+            // 403 = token works but missing profile scopes → save token, ask for URN
+            saveCredential(config, 'LINKEDIN_ACCESS_TOKEN', token);
+
+            await bot.sendMessage(chatId, [
+              '⚠️ *Token saved* but profile auto-detect unavailable.',
+              '',
+              'Your token lacks `openid`+`profile` scopes (only `w_member_social`).',
+              'To fix: add *"Sign in with LinkedIn using OpenID Connect"* to your app at the Developer Portal, then regenerate the token.',
+              '',
+              'For now, send your person URN to complete setup:',
+              '`/linkedin urn urn:li:person:XXXXX`',
+              '',
+              'Find your sub value in your LinkedIn Developer app → Auth tab.',
+            ].join('\n'), { parse_mode: 'Markdown' });
+          }
+        } catch (err) {
+          logger.error(`[Bot] LinkedIn token validation failed: ${err.message}`);
+          await bot.sendMessage(chatId, `❌ Token validation failed: ${err.message}`);
+        }
+        return;
+      }
+
+      // /linkedin urn <value> — manually set person URN
+      if (args.startsWith('urn')) {
+        const urn = args.slice('urn'.length).trim();
+        if (!urn) {
+          await bot.sendMessage(chatId, 'Usage: `/linkedin urn urn:li:person:XXXXX`', { parse_mode: 'Markdown' });
+          return;
+        }
+        const personUrn = urn.startsWith('urn:li:person:') ? urn : `urn:li:person:${urn}`;
+        const { saveCredential } = await import('./utils/config.js');
+        saveCredential(config, 'LINKEDIN_PERSON_URN', personUrn);
+
+        await bot.sendMessage(chatId, `✅ Person URN saved: \`${personUrn}\``, { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // /linkedin unlink — clear saved token
+      if (args === 'unlink') {
+        if (!config.linkedin?.access_token) {
+          await bot.sendMessage(chatId, 'Your LinkedIn account is not connected.');
+          return;
+        }
+
+        const { saveCredential } = await import('./utils/config.js');
+        saveCredential(config, 'LINKEDIN_ACCESS_TOKEN', '');
+        saveCredential(config, 'LINKEDIN_PERSON_URN', '');
+        // Clear from live config
+        config.linkedin.access_token = null;
+        config.linkedin.person_urn = null;
+
+        await bot.sendMessage(chatId, '✅ LinkedIn account disconnected.');
+        return;
+      }
+
+      // /linkedin (status) — show connection status
+      if (!config.linkedin?.access_token) {
+        await bot.sendMessage(chatId, [
+          '📱 *LinkedIn — Not Connected*',
+          '',
+          'Use `/linkedin link <token>` to connect your account.',
+          '',
+          'Get a token: https://www.linkedin.com/developers/tools/oauth/token-generator',
+        ].join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      await bot.sendMessage(chatId, [
+        '📱 *LinkedIn — Connected*',
+        '',
+        `🔑 Token: \`${config.linkedin.access_token.slice(0, 8)}...${config.linkedin.access_token.slice(-4)}\``,
+        config.linkedin.person_urn ? `👤 URN: \`${config.linkedin.person_urn}\`` : '',
+        '',
+        '`/linkedin unlink` — Disconnect account',
+      ].filter(Boolean).join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /x command ─────────────────────────────────────────────────
+    if (text === '/x' || text.startsWith('/x ')) {
+      logger.info(`[Bot] /x command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/x'.length).trim();
+
+      // /x link <consumer_key> <consumer_secret> <access_token> <access_token_secret>
+      if (args.startsWith('link')) {
+        const keys = args.slice('link'.length).trim().split(/\s+/);
+        if (keys.length !== 4) {
+          await bot.sendMessage(chatId, [
+            '🔗 *Connect your X (Twitter) account*',
+            '',
+            'You need 4 credentials from your X Developer App:',
+            '1. Consumer Key (API Key)',
+            '2. Consumer Secret (API Secret)',
+            '3. Access Token',
+            '4. Access Token Secret',
+            '',
+            'Run: `/x link <consumer_key> <consumer_secret> <access_token> <access_token_secret>`',
+            '',
+            '⚠️ Make sure your app has *Read and Write* permissions for posting tweets.',
+          ].join('\n'), { parse_mode: 'Markdown' });
+          return;
+        }
+
+        const [consumerKey, consumerSecret, accessToken, accessTokenSecret] = keys;
+        await bot.sendMessage(chatId, '⏳ Validating credentials...');
+
+        try {
+          const { XApi } = await import('./services/x-api.js');
+          const client = new XApi({ consumerKey, consumerSecret, accessToken, accessTokenSecret });
+          const profile = await client.getMe();
+
+          const { saveCredential } = await import('./utils/config.js');
+          saveCredential(config, 'X_CONSUMER_KEY', consumerKey);
+          saveCredential(config, 'X_CONSUMER_SECRET', consumerSecret);
+          saveCredential(config, 'X_ACCESS_TOKEN', accessToken);
+          saveCredential(config, 'X_ACCESS_TOKEN_SECRET', accessTokenSecret);
+
+          await bot.sendMessage(chatId, [
+            '✅ *X (Twitter) connected!*',
+            '',
+            `👤 *${profile.name}* (@${profile.username})`,
+            profile.description ? `📝 ${profile.description}` : '',
+            '',
+            'You can now ask me to tweet, search tweets, like, retweet, and more.',
+          ].filter(Boolean).join('\n'), { parse_mode: 'Markdown' });
+        } catch (err) {
+          logger.error(`[Bot] X token validation failed: ${err.message}`);
+          const detail = err.response?.data?.detail || err.response?.data?.title || err.message;
+          await bot.sendMessage(chatId, `❌ Validation failed: ${detail}`);
+        }
+        return;
+      }
+
+      // /x unlink — clear saved credentials
+      if (args === 'unlink') {
+        if (!config.x?.consumer_key) {
+          await bot.sendMessage(chatId, 'Your X account is not connected.');
+          return;
+        }
+
+        const { saveCredential } = await import('./utils/config.js');
+        saveCredential(config, 'X_CONSUMER_KEY', '');
+        saveCredential(config, 'X_CONSUMER_SECRET', '');
+        saveCredential(config, 'X_ACCESS_TOKEN', '');
+        saveCredential(config, 'X_ACCESS_TOKEN_SECRET', '');
+        config.x = {};
+
+        await bot.sendMessage(chatId, '✅ X (Twitter) account disconnected.');
+        return;
+      }
+
+      // /x (status) — show connection status
+      if (!config.x?.consumer_key) {
+        await bot.sendMessage(chatId, [
+          '🐦 *X (Twitter) — Not Connected*',
+          '',
+          'Use `/x link <consumer_key> <consumer_secret> <access_token> <access_token_secret>` to connect.',
+          '',
+          'Get credentials from https://developer.x.com/en/portal/dashboard',
+        ].join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      await bot.sendMessage(chatId, [
+        '🐦 *X (Twitter) — Connected*',
+        '',
+        `🔑 Consumer Key: \`${config.x.consumer_key.slice(0, 6)}...${config.x.consumer_key.slice(-4)}\``,
+        `🔑 Access Token: \`${config.x.access_token.slice(0, 6)}...${config.x.access_token.slice(-4)}\``,
+        '',
+        '`/x unlink` — Disconnect account',
+      ].join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
     if (text === '/help') {
       const activeSkill = agent.getActiveSkill(chatId);
       const skillLine = activeSkill
@@ -1550,6 +2258,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       await bot.sendMessage(chatId, [
         '*KernelBot Commands*',
         skillLine,
+        '/character — Switch or manage characters',
         '/brain — Switch worker AI model/provider',
         '/orchestrator — Switch orchestrator AI model/provider',
         '/claudemodel — Switch Claude Code model',
@@ -1563,6 +2272,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         '/journal — View today\'s journal or a past date',
         '/memories — View recent memories or search',
         '/evolution — Self-evolution status, history, lessons',
+        '/dashboard — Start/stop the monitoring dashboard',
+        '/linkedin — Link/unlink your LinkedIn account',
+        '/x — Link/unlink your X (Twitter) account',
         '/context — Show all models, auth, and context info',
         '/clean — Clear conversation and start fresh',
         '/history — Show message count in memory',