kernelbot 1.0.39 → 1.0.40

package/src/bot.js

@@ -4,14 +4,14 @@ import { isAllowedUser, getUnauthorizedMessage, alertAdmin } from './security/au
 import { getLogger } from './utils/logger.js';
 import { PROVIDERS } from './providers/models.js';
 import {
-  getUnifiedSkillById,
-  getUnifiedCategoryList,
-  getUnifiedSkillsByCategory,
-  loadCustomSkills,
-  addCustomSkill,
+  getSkillById,
+  getCategoryList,
+  getSkillsByCategory,
+  loadAllSkills,
+  saveCustomSkill,
   deleteCustomSkill,
   getCustomSkills,
-} from './skills/custom.js';
+} from './skills/loader.js';
 import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
@@ -206,6 +206,39 @@ class ChatQueue {
   }
 }
 
+/**
+ * Convert raw errors into user-friendly messages.
+ * Keeps technical details in logs, shows something helpful in chat.
+ */
+function _friendlyError(err) {
+  const msg = (err?.message || '').toLowerCase();
+
+  if (msg.includes('api key') || msg.includes('authentication') || msg.includes('unauthorized')) {
+    return '🔑 Authentication issue — please check your API key configuration.';
+  }
+  if (msg.includes('rate limit') || msg.includes('429') || msg.includes('quota')) {
+    return '⏳ Rate limited — too many requests. I\'ll be back in a moment, try again shortly.';
+  }
+  if (msg.includes('timed out') || msg.includes('timeout')) {
+    return '⏱️ The request timed out. Try again or simplify your request.';
+  }
+  if (msg.includes('context length') || msg.includes('too long') || msg.includes('too large') || msg.includes('token limit')) {
+    return '📏 Message too long for the current model. Try a shorter message or switch to a model with a larger context window.';
+  }
+  if (msg.includes('safety') || msg.includes('blocked') || msg.includes('recitation')) {
+    return '🛡️ The model declined this request due to safety filters. Try rephrasing.';
+  }
+  if (msg.includes('not found') || msg.includes('not available') || msg.includes('does not exist')) {
+    return '❓ The configured model is not available. Try switching to a different model with /brain.';
+  }
+  if (msg.includes('connection') || msg.includes('network') || msg.includes('fetch failed')) {
+    return '🌐 Network issue — couldn\'t reach the AI provider. Check your connection and try again.';
+  }
+
+  // Generic fallback — still don't expose raw internals
+  return '⚠️ Something went wrong processing your message. Try again, or switch models with /brain if the issue persists.';
+}
+
 export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
   let { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge, characterManager, dashboardHandle, dashboardDeps } = lifeDeps;
   const logger = getLogger();
@@ -281,7 +314,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   }
 
   // Load custom skills from disk
-  loadCustomSkills();
+  loadAllSkills();
 
   // Register commands in Telegram's menu button
   bot.setMyCommands([
@@ -392,7 +425,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
       } else if (data.startsWith('brain_model:')) {
         // User picked a model — attempt switch
-        const [, providerKey, modelId] = data.split(':');
+        // Use split with limit to avoid truncating model IDs containing colons
+        const parts = data.split(':');
+        const providerKey = parts[1];
+        const modelId = parts.slice(2).join(':');
         const providerDef = PROVIDERS[providerKey];
         const modelEntry = providerDef?.models.find((m) => m.id === modelId);
         const modelLabel = modelEntry ? modelEntry.label : modelId;
@@ -454,29 +490,34 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         });
         await bot.answerCallbackQuery(query.id);
 
-      // ── Skill callbacks ──────────────────────────────────────────
+      // ── Skill callbacks (multi-skill toggle) ─────────────────────
       } else if (data.startsWith('skill_category:')) {
         const categoryKey = data.split(':')[1];
-        const skills = getUnifiedSkillsByCategory(categoryKey);
-        const categories = getUnifiedCategoryList();
+        const skills = getSkillsByCategory(categoryKey);
+        const categories = getCategoryList();
         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 activeIds = new Set(agent.getActiveSkillIds(chatId));
         const buttons = skills.map((s) => ([{
-          text: `${s.emoji} ${s.name}${activeSkill && activeSkill.id === s.id ? ' ✓' : ''}`,
-          callback_data: `skill_select:${s.id}`,
+          text: `${activeIds.has(s.id) ? '✅ ' : ''}${s.emoji} ${s.name}`,
+          callback_data: `skill_toggle:${s.id}:${categoryKey}`,
         }]));
         buttons.push([
           { text: '« Back', callback_data: 'skill_back' },
-          { text: 'Cancel', callback_data: 'skill_cancel' },
+          { text: 'Done', callback_data: 'skill_cancel' },
         ]);
 
+        const activeSkills = agent.getActiveSkills(chatId);
+        const activeLine = activeSkills.length > 0
+          ? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`
+          : '';
+
         await bot.editMessageText(
-          `${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — select a skill:`,
+          `${activeLine}${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — tap to toggle:`,
           {
             chat_id: chatId,
             message_id: query.message.message_id,
@@ -486,31 +527,60 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         );
         await bot.answerCallbackQuery(query.id);
 
-      } else if (data.startsWith('skill_select:')) {
-        const skillId = data.split(':')[1];
-        const skill = getUnifiedSkillById(skillId);
+      } else if (data.startsWith('skill_toggle:')) {
+        const parts = data.split(':');
+        const skillId = parts[1];
+        const categoryKey = parts[2]; // to refresh the category view
+        const skill = getSkillById(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);
+        const { added, skills: currentSkills } = agent.toggleSkill(chatId, skillId);
+        if (!added && currentSkills.includes(skillId)) {
+          // Wasn't added because at max
+          await bot.answerCallbackQuery(query.id, { text: `Max ${5} skills reached. Remove one first.` });
+          return;
+        }
+
+        logger.info(`[Bot] Skill ${added ? 'activated' : 'deactivated'}: ${skill.name} (${skillId}) for chat ${chatId} — now ${currentSkills.length} active`);
+
+        // Refresh the category view with updated toggles
+        const catSkills = getSkillsByCategory(categoryKey);
+        const categories = getCategoryList();
+        const cat = categories.find((c) => c.key === categoryKey);
+        const activeIds = new Set(agent.getActiveSkillIds(chatId));
+
+        const buttons = catSkills.map((s) => ([{
+          text: `${activeIds.has(s.id) ? '✅ ' : ''}${s.emoji} ${s.name}`,
+          callback_data: `skill_toggle:${s.id}:${categoryKey}`,
+        }]));
+        buttons.push([
+          { text: '« Back', callback_data: 'skill_back' },
+          { text: 'Done', callback_data: 'skill_cancel' },
+        ]);
+
+        const activeSkills = agent.getActiveSkills(chatId);
+        const activeLine = activeSkills.length > 0
+          ? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`
+          : '';
+
         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.`,
+          `${activeLine}${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — tap to toggle:`,
           {
             chat_id: chatId,
             message_id: query.message.message_id,
             parse_mode: 'Markdown',
+            reply_markup: { inline_keyboard: buttons },
           },
         );
-        await bot.answerCallbackQuery(query.id);
+        await bot.answerCallbackQuery(query.id, { text: added ? `✅ ${skill.name} on` : `❌ ${skill.name} off` });
 
       } else if (data === 'skill_reset') {
-        logger.info(`[Bot] Skill reset for chat ${chatId}`);
+        logger.info(`[Bot] Skills cleared for chat ${chatId}`);
         agent.clearSkill(chatId);
-        await bot.editMessageText('🔄 Skill cleared — back to default persona.', {
+        await bot.editMessageText('🔄 All skills cleared — back to default persona.', {
           chat_id: chatId,
           message_id: query.message.message_id,
         });
@@ -551,10 +621,11 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       } 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);
+        // Remove from active skills if present
+        const activeIds = agent.getActiveSkillIds(chatId);
+        if (activeIds.includes(skillId)) {
+          logger.info(`[Bot] Removing deleted skill from active set: ${skillId}`);
+          agent.toggleSkill(chatId, skillId);
         }
         const deleted = deleteCustomSkill(skillId);
         const msg = deleted ? '🗑️ Custom skill deleted.' : 'Skill not found.';
@@ -566,8 +637,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
       } else if (data === 'skill_back') {
         // Re-show category list
-        const categories = getUnifiedCategoryList();
-        const activeSkill = agent.getActiveSkill(chatId);
+        const categories = getCategoryList();
+        const activeSkills = agent.getActiveSkills(chatId);
         const buttons = categories.map((cat) => ([{
           text: `${cat.emoji} ${cat.name} (${cat.count})`,
           callback_data: `skill_category:${cat.key}`,
@@ -578,15 +649,16 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           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' });
+        const footerRow = [{ text: 'Done', callback_data: 'skill_cancel' }];
+        if (activeSkills.length > 0) {
+          footerRow.unshift({ text: '🔄 Clear All', callback_data: 'skill_reset' });
         }
         buttons.push(footerRow);
 
-        const header = activeSkill
-          ? `🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n\nSelect a category:`
-          : '🎭 *Skills* — select a category:';
+        const activeLine = activeSkills.length > 0
+          ? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`
+          : '';
+        const header = `${activeLine}🎭 *Skills* — select a category:`;
 
         await bot.editMessageText(header, {
           chat_id: chatId,
@@ -597,9 +669,14 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         await bot.answerCallbackQuery(query.id);
 
       } else if (data === 'skill_cancel') {
-        await bot.editMessageText('Skill selection cancelled.', {
+        const activeSkills = agent.getActiveSkills(chatId);
+        const msg = activeSkills.length > 0
+          ? `🎭 Active skills (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}`
+          : 'No skills active.';
+        await bot.editMessageText(msg, {
           chat_id: chatId,
           message_id: query.message.message_id,
+          parse_mode: 'Markdown',
         });
         await bot.answerCallbackQuery(query.id);
 
@@ -685,7 +762,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         await bot.answerCallbackQuery(query.id);
 
       } else if (data.startsWith('orch_model:')) {
-        const [, providerKey, modelId] = data.split(':');
+        // Use split with limit to avoid truncating model IDs containing colons
+        const parts = data.split(':');
+        const providerKey = parts[1];
+        const modelId = parts.slice(2).join(':');
         const providerDef = PROVIDERS[providerKey];
         const modelEntry = providerDef?.models.find((m) => m.id === modelId);
         const modelLabel = modelEntry ? modelEntry.label : modelId;
@@ -1136,12 +1216,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
             return;
           }
           pendingCustomSkill.delete(chatId);
-          const skill = addCustomSkill({ name: pending.name, systemPrompt: content });
+          const skill = saveCustomSkill({ name: pending.name, body: 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);
+          agent.toggleSkill(chatId, skill.id);
           await bot.sendMessage(
             chatId,
-            `✅ Custom skill *${skill.name}* created and activated!\n\n_Prompt loaded from file (${content.length} chars)_`,
+            `✅ Custom skill *${skill.name}* created and added to active skills!\n\n_Prompt loaded from file (${content.length} chars)_`,
             { parse_mode: 'Markdown' },
           );
         } catch (err) {
@@ -1323,12 +1403,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
       if (pending.step === 'prompt') {
         pendingCustomSkill.delete(chatId);
-        const skill = addCustomSkill({ name: pending.name, systemPrompt: text });
+        const skill = saveCustomSkill({ name: pending.name, body: text });
         logger.info(`[Bot] Custom skill created: "${skill.name}" (${skill.id}) by ${username} in chat ${chatId}`);
-        agent.setSkill(chatId, skill.id);
+        agent.toggleSkill(chatId, skill.id);
         await bot.sendMessage(
           chatId,
-          `✅ Custom skill *${skill.name}* created and activated!`,
+          `✅ Custom skill *${skill.name}* created and added to active skills!`,
           { parse_mode: 'Markdown' },
         );
         return;
@@ -1536,14 +1616,14 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     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.');
+      await bot.sendMessage(chatId, '🔄 All skills 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 categories = getCategoryList();
+      const activeSkills = agent.getActiveSkills(chatId);
       const buttons = categories.map((cat) => ([{
         text: `${cat.emoji} ${cat.name} (${cat.count})`,
         callback_data: `skill_category:${cat.key}`,
@@ -1555,14 +1635,15 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       }
       buttons.push(customRow);
       const footerRow = [{ text: 'Cancel', callback_data: 'skill_cancel' }];
-      if (activeSkill) {
-        footerRow.unshift({ text: '🔄 Reset to Default', callback_data: 'skill_reset' });
+      if (activeSkills.length > 0) {
+        footerRow.unshift({ text: '🔄 Clear All', callback_data: 'skill_reset' });
       }
       buttons.push(footerRow);
 
-      const header = activeSkill
-        ? `🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n\nSelect a category:`
-        : '🎭 *Skills* — select a category:';
+      const activeLine = activeSkills.length > 0
+        ? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`
+        : '';
+      const header = `${activeLine}🎭 *Skills* — select a category:`;
 
       await bot.sendMessage(chatId, header, {
         parse_mode: 'Markdown',
@@ -1589,7 +1670,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       const orchInfo = agent.getOrchestratorInfo();
       const ccInfo = agent.getClaudeCodeInfo();
       const authConfig = agent.getClaudeAuthConfig();
-      const activeSkill = agent.getActiveSkill(chatId);
+      const activeSkills = agent.getActiveSkills(chatId);
       const msgCount = agent.getMessageCount(chatId);
       const history = agent.getConversationHistory(chatId);
       const maxHistory = conversationManager.maxHistory;
@@ -1615,9 +1696,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         `🎛️ *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',
+        activeSkills.length > 0
+          ? `🎭 *Skills (${activeSkills.length}):* ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}`
+          : '🎭 *Skills:* None (default persona)',
         `💬 *Messages in memory:* ${msgCount} / ${maxHistory}`,
         `📌 *Recent window:* ${recentWindow} messages`,
       ].filter(Boolean);
@@ -2251,9 +2332,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     }
 
     if (text === '/help') {
-      const activeSkill = agent.getActiveSkill(chatId);
-      const skillLine = activeSkill
-        ? `\n🎭 *Active skill:* ${activeSkill.emoji} ${activeSkill.name}\n`
+      const activeSkills = agent.getActiveSkills(chatId);
+      const skillLine = activeSkills.length > 0
+        ? `\n🎭 *Active skills:* ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n`
         : '';
       await bot.sendMessage(chatId, [
         '*KernelBot Commands*',
@@ -2263,8 +2344,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         '/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',
+        '/skills — Browse and toggle persona skills (multi-skill)',
+        '/skills reset — Clear all active skills',
         '/jobs — List running and recent jobs',
         '/cancel — Cancel running job(s)',
         '/auto — Manage recurring automations',
@@ -2477,7 +2558,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       } catch (err) {
         clearInterval(typingInterval);
         logger.error(`[Bot] Error processing message in chat ${chatId}: ${err.message}`);
-        await bot.sendMessage(chatId, `Error: ${err.message}`);
+        // Show a friendly message instead of raw error details
+        const friendly = _friendlyError(err);
+        await bot.sendMessage(chatId, friendly);
       }
     });
   });

package/src/coder.js

@@ -137,6 +137,8 @@ export class ClaudeCodeSpawner {
   constructor(config) {
     this.config = config;
     this.maxTurns = config.claude_code?.max_turns || 50;
+    // Default 24 hours — background workers can legitimately run for extended periods.
+    // Stuck process detection is handled separately by idle/loop heuristics.
     this.timeout = (config.claude_code?.timeout_seconds || 86400) * 1000;
   }
 
@@ -160,12 +162,18 @@ export class ClaudeCodeSpawner {
     }
     // authMode === 'system' — pass env as-is
 
-    return env;
+    
+    // FIX: Ensure system auth uses local credentials, not the bot's API key
+    if (authMode === 'system') {
+      delete env.ANTHROPIC_API_KEY;
+    }
+  return env;
   }
 
-  async run({ workingDirectory, prompt, maxTurns, onOutput, signal }) {
+  async run({ workingDirectory, prompt, maxTurns, timeoutMs, onOutput, signal }) {
     const logger = getLogger();
     const turns = maxTurns || this.maxTurns;
+    const effectiveTimeout = timeoutMs || this.timeout;
 
     ensureClaudeCodeSetup();
 
@@ -185,7 +193,7 @@ export class ClaudeCodeSpawner {
 
     const cmd = `claude ${args.map((a) => a.includes(' ') ? `"${a}"` : a).join(' ')}`;
     logger.info(`Spawning: ${cmd.slice(0, 300)}`);
-    logger.info(`CWD: ${workingDirectory}`);
+    logger.info(`CWD: ${workingDirectory} | Timeout: ${effectiveTimeout / 1000}s | Max turns: ${turns}`);
 
     // --- Smart output: consolidate tool activity into one editable message ---
     let statusMsgId = null;
@@ -216,7 +224,9 @@ export class ClaudeCodeSpawner {
         } else {
           statusMsgId = await onOutput(buildStatusText());
         }
-      } catch {}
+      } catch (err) {
+        logger.debug(`flushStatus failed: ${err.message}`);
+      }
     };
 
     const addActivity = (line) => {
@@ -301,10 +311,20 @@ export class ClaudeCodeSpawner {
       });
 
       const timer = setTimeout(() => {
+        logger.warn(`Claude Code timed out after ${effectiveTimeout / 1000}s — sending SIGTERM`);
         child.kill('SIGTERM');
-        if (smartOutput) smartOutput(`▸ Claude Code timed out after ${this.timeout / 1000}s`).catch(() => {});
-        reject(new Error(`Claude Code timed out after ${this.timeout / 1000}s`));
-      }, this.timeout);
+        if (smartOutput) smartOutput(`▸ Claude Code timed out after ${effectiveTimeout / 1000}s`).catch(() => {});
+
+        // Give it 10s to exit gracefully after SIGTERM, then force-kill
+        setTimeout(() => {
+          if (!child.killed) {
+            logger.warn('Claude Code did not exit after SIGTERM — sending SIGKILL');
+            child.kill('SIGKILL');
+          }
+        }, 10_000);
+
+        reject(new Error(`Claude Code timed out after ${effectiveTimeout / 1000}s`));
+      }, effectiveTimeout);
 
       child.on('close', async (code) => {
         clearTimeout(timer);
@@ -333,7 +353,9 @@ export class ClaudeCodeSpawner {
           const finalState = code === 0 ? 'done' : 'error';
           try {
             await onOutput(buildStatusText(finalState), { editMessageId: statusMsgId });
-          } catch {}
+          } catch (err) {
+            logger.debug(`Final status update failed: ${err.message}`);
+          }
         }
 
         logger.info(`Claude Code exited with code ${code} | stdout: ${fullOutput.length} chars | stderr: ${stderr.length} chars`);

package/src/conversation.js

@@ -43,10 +43,14 @@ export class ConversationManager {
       const raw = readFileSync(this.filePath, 'utf-8');
       const data = JSON.parse(raw);
 
-      // Restore per-chat skills
+      // Restore per-chat skills (backward compat: string → string[])
       if (data._skills && typeof data._skills === 'object') {
-        for (const [chatId, skillId] of Object.entries(data._skills)) {
-          this.activeSkills.set(String(chatId), skillId);
+        for (const [chatId, value] of Object.entries(data._skills)) {
+          // Old format stored a single string; new format stores an array
+          const skills = Array.isArray(value) ? value : (typeof value === 'string' ? [value] : []);
+          if (skills.length > 0) {
+            this.activeSkills.set(String(chatId), skills);
+          }
         }
       }
 
@@ -72,11 +76,11 @@ export class ConversationManager {
       for (const [chatId, messages] of this.conversations) {
         data[chatId] = messages;
       }
-      // Persist active skills under a reserved key
+      // Persist active skills under a reserved key (stored as arrays)
       if (this.activeSkills.size > 0) {
         const skills = {};
-        for (const [chatId, skillId] of this.activeSkills) {
-          skills[chatId] = skillId;
+        for (const [chatId, skillIds] of this.activeSkills) {
+          skills[chatId] = skillIds;
         }
         data._skills = skills;
       }
@@ -235,34 +239,107 @@ export class ConversationManager {
     return history.length;
   }
 
+  // ── Multi-skill methods ─────────────────────────────────────────────
+
+  /** Max active skills per chat. */
+  static MAX_SKILLS = 5;
+
   /**
-   * Activate a skill for a specific chat, persisted across restarts.
-   * @param {string|number} chatId - Telegram chat identifier.
-   * @param {string} skillId - Skill identifier to activate.
+   * Replace all active skills for a chat.
+   * @param {string|number} chatId
+   * @param {string[]} skillIds
    */
-  setSkill(chatId, skillId) {
-    this.activeSkills.set(String(chatId), skillId);
+  setSkills(chatId, skillIds) {
+    const ids = skillIds.slice(0, ConversationManager.MAX_SKILLS);
+    this.activeSkills.set(String(chatId), ids);
     this.save();
   }
 
   /**
-   * Get the currently active skill for a chat.
-   * @param {string|number} chatId - Telegram chat identifier.
-   * @returns {string|null} Active skill identifier, or null if none.
+   * Add a skill to a chat's active set. No-op if already active or at max.
+   * @param {string|number} chatId
+   * @param {string} skillId
+   * @returns {boolean} true if added, false if already active or at max
    */
-  getSkill(chatId) {
-    return this.activeSkills.get(String(chatId)) || null;
+  addSkill(chatId, skillId) {
+    const key = String(chatId);
+    const current = this.activeSkills.get(key) || [];
+    if (current.includes(skillId)) return false;
+    if (current.length >= ConversationManager.MAX_SKILLS) return false;
+    current.push(skillId);
+    this.activeSkills.set(key, current);
+    this.save();
+    return true;
   }
 
   /**
-   * Deactivate the active skill for a chat.
-   * @param {string|number} chatId - Telegram chat identifier.
+   * Remove a skill from a chat's active set.
+   * @param {string|number} chatId
+   * @param {string} skillId
+   * @returns {boolean} true if removed
    */
-  clearSkill(chatId) {
+  removeSkill(chatId, skillId) {
+    const key = String(chatId);
+    const current = this.activeSkills.get(key) || [];
+    const idx = current.indexOf(skillId);
+    if (idx === -1) return false;
+    current.splice(idx, 1);
+    if (current.length === 0) {
+      this.activeSkills.delete(key);
+    } else {
+      this.activeSkills.set(key, current);
+    }
+    this.save();
+    return true;
+  }
+
+  /**
+   * Get all active skill IDs for a chat.
+   * @param {string|number} chatId
+   * @returns {string[]} Array of active skill IDs (empty if none).
+   */
+  getSkills(chatId) {
+    return this.activeSkills.get(String(chatId)) || [];
+  }
+
+  /**
+   * Clear all active skills for a chat.
+   * @param {string|number} chatId
+   */
+  clearSkills(chatId) {
     this.activeSkills.delete(String(chatId));
     this.save();
   }
 
+  // ── Backward-compatible single-skill aliases ───────────────────────
+
+  /**
+   * Activate a single skill (replaces all). Backward compat.
+   * @param {string|number} chatId
+   * @param {string} skillId
+   */
+  setSkill(chatId, skillId) {
+    this.setSkills(chatId, [skillId]);
+  }
+
+  /**
+   * Get the first active skill ID (or null). Backward compat.
+   * @param {string|number} chatId
+   * @returns {string|null}
+   */
+  getSkill(chatId) {
+    const skills = this.getSkills(chatId);
+    return skills.length > 0 ? skills[0] : null;
+  }
+
+  /**
+   * Deactivate all skills. Backward compat alias for clearSkills.
+   * @param {string|number} chatId
+   */
+  clearSkill(chatId) {
+    this.clearSkills(chatId);
+  }
+
   /**
    * Switch the backing file for this manager.
    * Saves current data, clears in-memory state, then loads from the new file.

package/src/dashboard/dashboard.css

@@ -156,6 +156,12 @@
 .auto-name { color: var(--accent); font-weight: 600; font-family: var(--font-hud); font-size: 9px; letter-spacing: 1px; }
 .auto-detail { color: var(--dim); font-size: 10px; }
 
+/* ═══════ SKILLS ═══════ */
+.skill-item { padding: 2px 0; border-bottom: 1px solid rgba(57,255,20,0.03); }
+.skill-emoji { margin-right: 4px; }
+.skill-name { color: var(--accent); font-family: var(--font-hud); font-size: 10px; letter-spacing: 0.5px; }
+.skill-desc { color: var(--dim); font-size: 9px; margin-top: 1px; }
+
 /* ═══════ MARKDOWN CONTENT ═══════ */
 .md-content { white-space: pre-wrap; word-wrap: break-word; color: var(--text); font-size: 11px; }
 .md-content .ts-line { color: var(--accent); }