kernelbot 1.0.39 → 1.0.40

package/src/agent.js

@@ -1,10 +1,11 @@
-import { createProvider, PROVIDERS } from './providers/index.js';
+import { createProvider, PROVIDERS, MODEL_FALLBACKS } from './providers/index.js';
+import { BaseProvider } from './providers/base.js';
 import { orchestratorToolDefinitions, executeOrchestratorTool } from './tools/orchestrator-tools.js';
 import { getToolsForWorker } from './swarm/worker-registry.js';
 import { WORKER_TYPES } from './swarm/worker-registry.js';
 import { getOrchestratorPrompt } from './prompts/orchestrator.js';
 import { getWorkerPrompt } from './prompts/workers.js';
-import { getUnifiedSkillById } from './skills/custom.js';
+import { getSkillById, buildSkillPrompt, filterSkillsForWorker } from './skills/loader.js';
 import { WorkerAgent } from './worker.js';
 import { getLogger } from './utils/logger.js';
 import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestratorToYaml, saveClaudeCodeModelToYaml, saveClaudeCodeAuth } from './utils/config.js';
@@ -79,8 +80,8 @@ export class OrchestratorAgent {
   _getSystemPrompt(chatId, user, temporalContext = null) {
     const logger = getLogger();
     const key = this._chatKey(chatId);
-    const skillId = this.conversationManager.getSkill(key);
-    const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
+    const skillIds = this.conversationManager.getSkills(key);
+    const skillPrompt = buildSkillPrompt(skillIds);
 
     let userPersona = null;
     if (this.personaManager && user?.id) {
@@ -104,21 +105,47 @@ export class OrchestratorAgent {
       sharesBlock = this.shareQueue.buildShareBlock(user?.id || null);
     }
 
-    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skill=${skillId || 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'} | memories=${memoriesBlock ? 'yes' : 'none'} | shares=${sharesBlock ? 'yes' : 'none'} | temporal=${temporalContext ? 'yes' : 'none'} | character=${this._activeCharacterId || 'default'}`);
+    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skills=${skillIds.length > 0 ? skillIds.join(',') : 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'} | memories=${memoriesBlock ? 'yes' : 'none'} | shares=${sharesBlock ? 'yes' : 'none'} | temporal=${temporalContext ? 'yes' : 'none'} | character=${this._activeCharacterId || 'default'}`);
     return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext, this._activePersonaMd, this._activeCharacterName);
   }
 
+  // ── Multi-skill methods ─────────────────────────────────────────────
+
+  /** Toggle a skill on/off for a chat. Returns { added: bool, skills: string[] }. */
+  toggleSkill(chatId, skillId) {
+    const key = this._chatKey(chatId);
+    const current = this.conversationManager.getSkills(key);
+    if (current.includes(skillId)) {
+      this.conversationManager.removeSkill(key, skillId);
+      return { added: false, skills: this.conversationManager.getSkills(key) };
+    }
+    const added = this.conversationManager.addSkill(key, skillId);
+    return { added, skills: this.conversationManager.getSkills(key) };
+  }
+
+  /** Get all active skill IDs for a chat. */
+  getActiveSkillIds(chatId) {
+    return this.conversationManager.getSkills(this._chatKey(chatId));
+  }
+
+  /** Get all active skill objects for a chat. */
+  getActiveSkills(chatId) {
+    const ids = this.getActiveSkillIds(chatId);
+    return ids.map(id => getSkillById(id)).filter(Boolean);
+  }
+
+  // Backward-compat aliases
   setSkill(chatId, skillId) {
     this.conversationManager.setSkill(this._chatKey(chatId), skillId);
   }
 
   clearSkill(chatId) {
-    this.conversationManager.clearSkill(this._chatKey(chatId));
+    this.conversationManager.clearSkills(this._chatKey(chatId));
   }
 
   getActiveSkill(chatId) {
-    const skillId = this.conversationManager.getSkill(this._chatKey(chatId));
-    return skillId ? getUnifiedSkillById(skillId) : null;
+    const skills = this.getActiveSkills(chatId);
+    return skills.length > 0 ? skills[0] : null;
   }
 
   /**
@@ -508,44 +535,52 @@ export class OrchestratorAgent {
 
       logger.info(`[Orchestrator] Job completed event: ${job.id} [${job.workerType}] in chat ${chatId} (${job.duration}s) — result length: ${(job.result || '').length} chars, structured: ${!!job.structuredResult}`);
 
-      // 1. IMMEDIATELY notify user (guarantees they see something regardless of summary LLM)
-      const notifyMsgId = await this._sendUpdate(chatId, `✅ ${label} finished! Preparing summary...`);
-      logger.debug(`[Orchestrator] Job ${job.id} notification sent — msgId=${notifyMsgId || 'none'}`);
+      // 1. Store the job result in conversation history so the Orchestrator has full context
+      const resultEntry = this._buildResultHistoryEntry(job);
+      this.conversationManager.addMessage(convKey, 'assistant', resultEntry);
 
-      // 2. Try to summarize, then store ONE message in history (summary or fallback — not both)
+      // 2. Trigger a proactive Orchestrator generation — inject the job result as context
+      //    and let the Orchestrator speak naturally (present results, suggest next steps, etc.)
       try {
-        const summary = await this._summarizeJobResult(chatId, job);
-        if (summary) {
-          logger.debug(`[Orchestrator] Job ${job.id} summary ready (${summary.length} chars) — delivering to user`);
-          this.conversationManager.addMessage(convKey, 'assistant', summary);
-          // Try to edit the notification, fall back to new message if edit fails
-          try {
-            await this._sendUpdate(chatId, summary, { editMessageId: notifyMsgId });
-          } catch {
-            await this._sendUpdate(chatId, summary).catch(() => {});
+        const sr = job.structuredResult;
+        let resultContext;
+        if (sr?.structured) {
+          const parts = [`Summary: ${sr.summary}`, `Status: ${sr.status}`];
+          if (sr.artifacts?.length > 0) {
+            parts.push(`Artifacts: ${sr.artifacts.map(a => `${a.title || a.type}: ${a.url || a.path || ''}`).join(', ')}`);
           }
-        } else {
-          // Summary was null — store the fallback
-          const fallback = this._buildSummaryFallback(job, label);
-          logger.debug(`[Orchestrator] Job ${job.id} using fallback (${fallback.length} chars) — delivering to user`);
-          this.conversationManager.addMessage(convKey, 'assistant', fallback);
-          try {
-            await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
-          } catch {
-            await this._sendUpdate(chatId, fallback).catch(() => {});
+          if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
+          if (sr.details) {
+            const d = typeof sr.details === 'string' ? sr.details : JSON.stringify(sr.details, null, 2);
+            parts.push(`Details:\n${d.slice(0, 4000)}`);
           }
+          resultContext = parts.join('\n');
+        } else {
+          resultContext = (job.result || 'Done.').slice(0, 4000);
+        }
+
+        const triggerMessage = `[System: The ${label} worker just finished job \`${job.id}\` (took ${job.duration}s). Results:\n\n${resultContext}\n\nProactively notify the user about the completed task. Present the results naturally, celebrate if appropriate, and suggest next steps. Do NOT mention "worker" or internal job details — speak as if you did the work yourself.]`;
+
+        // Add trigger as a transient user message (not stored in persistent history)
+        const messages = [...this.conversationManager.getSummarizedHistory(convKey)];
+        messages.push({ role: 'user', content: triggerMessage });
+
+        logger.info(`[Orchestrator] Triggering proactive follow-up for job ${job.id} in chat ${chatId}`);
+
+        const { max_tool_depth } = this.config.orchestrator;
+        const reply = await this._runLoop(chatId, messages, null, 0, max_tool_depth);
+
+        if (reply) {
+          logger.info(`[Orchestrator] Proactive reply for job ${job.id}: "${reply.slice(0, 200)}"`);
+          // _runLoop already stores the reply in conversation history
+          await this._sendUpdate(chatId, reply);
         }
       } catch (err) {
-        logger.error(`[Orchestrator] Failed to summarize job ${job.id}: ${err.message}`);
-        // Store the fallback so the orchestrator retains context about what happened
+        logger.error(`[Orchestrator] Proactive follow-up failed for job ${job.id}: ${err.message}`);
+        // Fallback: send a simple formatted summary so the user isn't left hanging
         const fallback = this._buildSummaryFallback(job, label);
         this.conversationManager.addMessage(convKey, 'assistant', fallback);
-        // Try to edit notification, fall back to new message
-        try {
-          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
-        } catch {
-          await this._sendUpdate(chatId, fallback).catch(() => {});
-        }
+        await this._sendUpdate(chatId, fallback).catch(() => {});
       }
     });
 
@@ -564,7 +599,7 @@ export class OrchestratorAgent {
       }
     });
 
-    this.jobManager.on('job:failed', (job) => {
+    this.jobManager.on('job:failed', async (job) => {
       const chatId = job.chatId;
       const convKey = this._chatKey(chatId);
       const workerDef = WORKER_TYPES[job.workerType] || {};
@@ -572,9 +607,32 @@ export class OrchestratorAgent {
 
       logger.error(`[Orchestrator] Job failed event: ${job.id} [${job.workerType}] in chat ${chatId} — ${job.error}`);
 
-      const msg = `❌ **${label} failed** (\`${job.id}\`): ${job.error}`;
-      this.conversationManager.addMessage(convKey, 'assistant', msg);
-      this._sendUpdate(chatId, msg).catch(() => {});
+      // Store failure context in history
+      const failMsg = `[${label} failed — job ${job.id}]: ${job.error}`;
+      this.conversationManager.addMessage(convKey, 'assistant', failMsg);
+
+      // Trigger proactive Orchestrator follow-up for the failure
+      try {
+        const triggerMessage = `[System: The ${label} worker failed on job \`${job.id}\`. Error: ${job.error}\n\nProactively notify the user about the failure. Explain what went wrong in simple terms, apologize if appropriate, and suggest how to fix or retry. Do NOT mention "worker" or internal job details — speak as if you encountered the issue yourself.]`;
+
+        const messages = [...this.conversationManager.getSummarizedHistory(convKey)];
+        messages.push({ role: 'user', content: triggerMessage });
+
+        logger.info(`[Orchestrator] Triggering proactive follow-up for failed job ${job.id} in chat ${chatId}`);
+
+        const { max_tool_depth } = this.config.orchestrator;
+        const reply = await this._runLoop(chatId, messages, null, 0, max_tool_depth);
+
+        if (reply) {
+          logger.info(`[Orchestrator] Proactive failure reply for job ${job.id}: "${reply.slice(0, 200)}"`);
+          await this._sendUpdate(chatId, reply);
+        }
+      } catch (err) {
+        logger.error(`[Orchestrator] Proactive failure follow-up failed for job ${job.id}: ${err.message}`);
+        // Fallback: send the simple failure message
+        const fallback = `❌ **${label} failed** (\`${job.id}\`): ${job.error}`;
+        await this._sendUpdate(chatId, fallback).catch(() => {});
+      }
     });
 
     this.jobManager.on('job:cancelled', (job) => {
@@ -589,73 +647,6 @@ export class OrchestratorAgent {
     });
   }
 
-  /**
-   * Auto-summarize a completed job result via the orchestrator LLM.
-   * Uses structured data for focused summarization when available.
-   * Short results (<500 chars) skip the LLM call entirely.
-   * Protected by the provider's built-in timeout (30s).
-   * Returns the summary text, or null. Caller handles delivery.
-   */
-  async _summarizeJobResult(chatId, job) {
-    const logger = getLogger();
-    const workerDef = WORKER_TYPES[job.workerType] || {};
-    const label = workerDef.label || job.workerType;
-
-    logger.info(`[Orchestrator] Summarizing job ${job.id} [${job.workerType}] result for user`);
-
-    const sr = job.structuredResult;
-    const resultLen = (job.result || '').length;
-
-    // Direct coding jobs: Claude Code already produces clean, human-readable output.
-    // Skip LLM summarization to avoid timeouts and latency — use the result directly.
-    if (job.workerType === 'coding') {
-      logger.info(`[Orchestrator] Job ${job.id} is a coding job — using direct result (no LLM summary)`);
-      return this._buildSummaryFallback(job, label);
-    }
-
-    // Short results don't need LLM summarization
-    if (sr?.structured && resultLen < 500) {
-      logger.info(`[Orchestrator] Job ${job.id} result short enough — skipping LLM summary`);
-      return this._buildSummaryFallback(job, label);
-    }
-
-    // Build a focused prompt using structured data if available
-    let resultContext;
-    if (sr?.structured) {
-      const parts = [`Summary: ${sr.summary}`, `Status: ${sr.status}`];
-      if (sr.artifacts?.length > 0) {
-        parts.push(`Artifacts: ${sr.artifacts.map(a => `${a.title || a.type}: ${a.url || a.path}`).join(', ')}`);
-      }
-      if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
-      // Include details up to 8000 chars
-      if (sr.details) {
-        const d = typeof sr.details === 'string' ? sr.details : JSON.stringify(sr.details, null, 2);
-        parts.push(`Details:\n${d.slice(0, 8000)}`);
-      }
-      resultContext = parts.join('\n');
-    } else {
-      resultContext = (job.result || 'Done.').slice(0, 8000);
-    }
-
-    const history = this.conversationManager.getSummarizedHistory(this._chatKey(chatId));
-
-    const response = await this.orchestratorProvider.chat({
-      system: this._getSystemPrompt(chatId, null),
-      messages: [
-        ...history,
-        {
-          role: 'user',
-          content: `The ${label} worker just finished job \`${job.id}\` (took ${job.duration}s). Here are the results:\n\n${resultContext}\n\nPresent these results to the user in a clean, well-formatted way. Don't mention "worker" or technical job details — just present the findings naturally as if you did the work yourself.`,
-        },
-      ],
-    });
-
-    const summary = response.text || '';
-    logger.info(`[Orchestrator] Job ${job.id} summary: "${summary.slice(0, 200)}"`);
-
-    return summary || null;
-  }
-
   /**
    * Build a compact history entry for a completed job result.
    * Stored as role: 'assistant' (not fake 'user') with up to 6000 chars of detail.
@@ -862,9 +853,10 @@ export class OrchestratorAgent {
       }
     };
 
-    // Get scoped tools and skill
+    // Get scoped tools and skills (filtered by worker affinity)
     const tools = getToolsForWorker(job.workerType);
-    const skillId = this.conversationManager.getSkill(this._chatKey(chatId));
+    const allSkillIds = this.conversationManager.getSkills(this._chatKey(chatId));
+    const workerSkillIds = filterSkillsForWorker(allSkillIds, job.workerType);
 
     // Build worker context (conversation history, persona, dependency results)
     const workerContext = this._buildWorkerContext(job);
@@ -880,14 +872,14 @@ export class OrchestratorAgent {
       }
     }
 
-    logger.debug(`[Orchestrator] Worker ${job.id} config: ${tools.length} tools, skill=${skillId || 'none'}, brain=${this.config.brain.provider}/${this.config.brain.model}, context=${workerContext ? 'yes' : 'none'}`);
+    logger.debug(`[Orchestrator] Worker ${job.id} config: ${tools.length} tools, skills=${workerSkillIds.length > 0 ? workerSkillIds.join(',') : 'none'}, brain=${this.config.brain.provider}/${this.config.brain.model}, context=${workerContext ? 'yes' : 'none'}`);
 
     const worker = new WorkerAgent({
       config: workerConfig,
       workerType: job.workerType,
       jobId: job.id,
       tools,
-      skillId,
+      skillIds: workerSkillIds,
       workerContext,
       callbacks: {
         onProgress: (text) => addActivity(text),
@@ -1129,11 +1121,54 @@ export class OrchestratorAgent {
         workingMessages = [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...workingMessages];
       }
 
-      const response = await this.orchestratorProvider.chat({
-        system: this._getSystemPrompt(chatId, user, temporalContext),
-        messages: workingMessages,
-        tools: orchestratorToolDefinitions,
-      });
+      let response;
+      let activeProvider = this.orchestratorProvider;
+
+      try {
+        response = await activeProvider.chat({
+          system: this._getSystemPrompt(chatId, user, temporalContext),
+          messages: workingMessages,
+          tools: orchestratorToolDefinitions,
+        });
+      } catch (err) {
+        // If this is a model limitation, try falling back to a simpler model
+        const currentModel = activeProvider.model;
+        const fallbackModel = MODEL_FALLBACKS[currentModel];
+
+        if (fallbackModel && BaseProvider.isModelLimitation(err)) {
+          logger.warn(`[Orchestrator] Model ${currentModel} hit limitation: ${err.message} — falling back to ${fallbackModel}`);
+          this._sendUpdate(chatId, `⚠️ ${currentModel} hit a limitation, switching to ${fallbackModel}...`).catch(() => {});
+
+          try {
+            const orchProviderKey = this.config.orchestrator.provider || 'anthropic';
+            const orchProviderDef = PROVIDERS[orchProviderKey];
+            const orchApiKey = this.config.orchestrator.api_key || (orchProviderDef && process.env[orchProviderDef.envKey]);
+
+            const fallbackProvider = createProvider({
+              brain: {
+                provider: orchProviderKey,
+                model: fallbackModel,
+                max_tokens: this.config.orchestrator.max_tokens,
+                temperature: this.config.orchestrator.temperature,
+                api_key: orchApiKey,
+                timeout: 30_000,
+              },
+            });
+
+            response = await fallbackProvider.chat({
+              system: this._getSystemPrompt(chatId, user, temporalContext),
+              messages: workingMessages,
+              tools: orchestratorToolDefinitions,
+            });
+            activeProvider = fallbackProvider;
+          } catch (fallbackErr) {
+            logger.error(`[Orchestrator] Fallback model ${fallbackModel} also failed: ${fallbackErr.message}`);
+            throw err; // Throw the original error
+          }
+        } else {
+          throw err;
+        }
+      }
 
       logger.info(`[Orchestrator] LLM response: stopReason=${response.stopReason}, text=${(response.text || '').length} chars, toolCalls=${(response.toolCalls || []).length}`);
 

package/src/automation/scheduler.js

@@ -108,7 +108,13 @@ function nextCronTime(expression, after) {
 }
 
 /**
- * Parse a single cron field into a Set of valid values.
+ * Parse a single cron field into a Set of valid integer values.
+ *
+ * @param {string} field - Cron field expression (e.g. '*', '1-5', '*\/10', '1,3,5')
+ * @param {number} min   - Minimum allowed value for this field (inclusive)
+ * @param {number} max   - Maximum allowed value for this field (inclusive)
+ * @returns {Set<number>} Set of matching integer values clamped to [min, max]
+ * @throws {Error} If the field contains invalid syntax or out-of-range values
  */
 function parseField(field, min, max) {
   const values = new Set();
@@ -119,21 +125,48 @@ function parseField(field, min, max) {
     } else if (part.includes('/')) {
       const [range, stepStr] = part.split('/');
       const step = parseInt(stepStr, 10);
+      if (isNaN(step) || step <= 0) {
+        throw new Error(`Invalid cron step value "${stepStr}" in field "${field}"`);
+      }
       let start = min;
       let end = max;
       if (range !== '*') {
         if (range.includes('-')) {
-          [start, end] = range.split('-').map(Number);
+          const parts = range.split('-').map(Number);
+          start = parts[0];
+          end = parts[1];
+          if (isNaN(start) || isNaN(end)) {
+            throw new Error(`Invalid cron range "${range}" in field "${field}"`);
+          }
         } else {
           start = parseInt(range, 10);
+          if (isNaN(start)) {
+            throw new Error(`Invalid cron value "${range}" in field "${field}"`);
+          }
         }
       }
+      if (start < min || end > max) {
+        throw new Error(`Cron field value out of range [${min}-${max}] in "${field}"`);
+      }
       for (let i = start; i <= end; i += step) values.add(i);
     } else if (part.includes('-')) {
       const [s, e] = part.split('-').map(Number);
+      if (isNaN(s) || isNaN(e)) {
+        throw new Error(`Invalid cron range "${part}" in field "${field}"`);
+      }
+      if (s < min || e > max) {
+        throw new Error(`Cron field value out of range [${min}-${max}] in "${field}"`);
+      }
       for (let i = s; i <= e; i++) values.add(i);
     } else {
-      values.add(parseInt(part, 10));
+      const val = parseInt(part, 10);
+      if (isNaN(val)) {
+        throw new Error(`Invalid cron value "${part}" in field "${field}"`);
+      }
+      if (val < min || val > max) {
+        throw new Error(`Cron field value ${val} out of range [${min}-${max}] in "${field}"`);
+      }
+      values.add(val);
     }
   }