kernelbot 1.0.32 → 1.0.34

package/bin/kernel.js

@@ -9,7 +9,7 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import chalk from 'chalk';
-import { loadConfig, loadConfigInteractive, changeBrainModel } from '../src/utils/config.js';
+import { loadConfig, loadConfigInteractive, changeBrainModel, changeOrchestratorModel } from '../src/utils/config.js';
 import { createLogger, getLogger } from '../src/utils/logger.js';
 import {
   showLogo,
@@ -40,11 +40,16 @@ import {
 } from '../src/skills/custom.js';
 
 function showMenu(config) {
+  const orchProviderDef = PROVIDERS[config.orchestrator.provider];
+  const orchProviderName = orchProviderDef ? orchProviderDef.name : config.orchestrator.provider;
+  const orchModelId = config.orchestrator.model;
+
   const providerDef = PROVIDERS[config.brain.provider];
   const providerName = providerDef ? providerDef.name : config.brain.provider;
   const modelId = config.brain.model;
 
   console.log('');
+  console.log(chalk.dim(`  Current orchestrator: ${orchProviderName} / ${orchModelId}`));
   console.log(chalk.dim(`  Current brain: ${providerName} / ${modelId}`));
   console.log('');
   console.log(chalk.bold('  What would you like to do?\n'));
@@ -53,9 +58,10 @@ function showMenu(config) {
   console.log(`  ${chalk.cyan('3.')} View logs`);
   console.log(`  ${chalk.cyan('4.')} View audit logs`);
   console.log(`  ${chalk.cyan('5.')} Change brain model`);
-  console.log(`  ${chalk.cyan('6.')} Manage custom skills`);
-  console.log(`  ${chalk.cyan('7.')} Manage automations`);
-  console.log(`  ${chalk.cyan('8.')} Exit`);
+  console.log(`  ${chalk.cyan('6.')} Change orchestrator model`);
+  console.log(`  ${chalk.cyan('7.')} Manage custom skills`);
+  console.log(`  ${chalk.cyan('8.')} Manage automations`);
+  console.log(`  ${chalk.cyan('9.')} Exit`);
   console.log('');
 }
 
@@ -95,23 +101,53 @@ function viewLog(filename) {
 }
 
 async function runCheck(config) {
+  // Orchestrator check
+  const orchProviderKey = config.orchestrator.provider || 'anthropic';
+  const orchProviderDef = PROVIDERS[orchProviderKey];
+  const orchLabel = orchProviderDef ? orchProviderDef.name : orchProviderKey;
+  const orchEnvKey = orchProviderDef ? orchProviderDef.envKey : 'ANTHROPIC_API_KEY';
+
+  await showStartupCheck(`Orchestrator ${orchEnvKey}`, async () => {
+    const orchestratorKey = config.orchestrator.api_key
+      || (orchProviderDef && process.env[orchProviderDef.envKey])
+      || process.env.ANTHROPIC_API_KEY;
+    if (!orchestratorKey) throw new Error('Not set');
+  });
+
+  await showStartupCheck(`Orchestrator (${orchLabel}) API connection`, async () => {
+    const orchestratorKey = config.orchestrator.api_key
+      || (orchProviderDef && process.env[orchProviderDef.envKey])
+      || process.env.ANTHROPIC_API_KEY;
+    const provider = createProvider({
+      brain: {
+        provider: orchProviderKey,
+        model: config.orchestrator.model,
+        max_tokens: config.orchestrator.max_tokens,
+        temperature: config.orchestrator.temperature,
+        api_key: orchestratorKey,
+      },
+    });
+    await provider.ping();
+  });
+
+  // Worker brain check
   const providerDef = PROVIDERS[config.brain.provider];
   const providerLabel = providerDef ? providerDef.name : config.brain.provider;
   const envKeyLabel = providerDef ? providerDef.envKey : 'API_KEY';
 
-  await showStartupCheck(envKeyLabel, async () => {
+  await showStartupCheck(`Worker ${envKeyLabel}`, async () => {
     if (!config.brain.api_key) throw new Error('Not set');
   });
 
-  await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
-    if (!config.telegram.bot_token) throw new Error('Not set');
-  });
-
-  await showStartupCheck(`${providerLabel} API connection`, async () => {
+  await showStartupCheck(`Worker (${providerLabel}) API connection`, async () => {
     const provider = createProvider(config);
     await provider.ping();
   });
 
+  await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
+    if (!config.telegram.bot_token) throw new Error('Not set');
+  });
+
   await showStartupCheck('Telegram Bot API', async () => {
     const res = await fetch(
       `https://api.telegram.org/bot${config.telegram.bot_token}/getMe`,
@@ -429,12 +465,15 @@ async function main() {
         await changeBrainModel(config, rl);
         break;
       case '6':
-        await manageCustomSkills(rl);
+        await changeOrchestratorModel(config, rl);
         break;
       case '7':
-        await manageAutomations(rl);
+        await manageCustomSkills(rl);
         break;
       case '8':
+        await manageAutomations(rl);
+        break;
+      case '9':
         running = false;
         break;
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -31,6 +31,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@google/genai": "^1.42.0",
     "@octokit/rest": "^22.0.1",
     "axios": "^1.13.5",
     "boxen": "^8.0.1",

package/src/agent.js

@@ -9,9 +9,7 @@ import { WorkerAgent } from './worker.js';
 import { getLogger } from './utils/logger.js';
 import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestratorToYaml, saveClaudeCodeModelToYaml, saveClaudeCodeAuth } from './utils/config.js';
 import { resetClaudeCodeSpawner, getSpawner } from './tools/coding.js';
-
-const MAX_RESULT_LENGTH = 3000;
-const LARGE_FIELDS = ['stdout', 'stderr', 'content', 'diff', 'output', 'body', 'html', 'text', 'log', 'logs'];
+import { truncateToolResult } from './utils/truncate.js';
 
 export class OrchestratorAgent {
   constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue }) {
@@ -49,7 +47,7 @@ export class OrchestratorAgent {
   }
 
   /** Build the orchestrator system prompt. */
-  _getSystemPrompt(chatId, user) {
+  _getSystemPrompt(chatId, user, temporalContext = null) {
     const logger = getLogger();
     const skillId = this.conversationManager.getSkill(chatId);
     const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
@@ -76,8 +74,8 @@ 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'}`);
-    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock);
+    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'}`);
+    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext);
   }
 
   setSkill(chatId, skillId) {
@@ -282,32 +280,18 @@ export class OrchestratorAgent {
     }
   }
 
-  /** Truncate a tool result. */
+  /** Truncate a tool result. Delegates to shared utility. */
   _truncateResult(name, result) {
-    let str = JSON.stringify(result);
-    if (str.length <= MAX_RESULT_LENGTH) return str;
-
-    if (result && typeof result === 'object') {
-      const truncated = { ...result };
-      for (const field of LARGE_FIELDS) {
-        if (typeof truncated[field] === 'string' && truncated[field].length > 500) {
-          truncated[field] = truncated[field].slice(0, 500) + `\n... [truncated ${truncated[field].length - 500} chars]`;
-        }
-      }
-      str = JSON.stringify(truncated);
-      if (str.length <= MAX_RESULT_LENGTH) return str;
-    }
-
-    return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
+    return truncateToolResult(name, result);
   }
 
-  async processMessage(chatId, userMessage, user, onUpdate, sendPhoto) {
+  async processMessage(chatId, userMessage, user, onUpdate, sendPhoto, opts = {}) {
     const logger = getLogger();
 
     logger.info(`Orchestrator processing message for chat ${chatId} from ${user?.username || user?.id || 'unknown'}: "${userMessage.slice(0, 120)}"`);
 
     // Store callbacks so workers can use them later
-    this._chatCallbacks.set(chatId, { onUpdate, sendPhoto });
+    this._chatCallbacks.set(chatId, { onUpdate, sendPhoto, sendReaction: opts.sendReaction, lastUserMessageId: opts.messageId });
 
     // Handle pending responses (confirmation or credential)
     const pending = this._pending.get(chatId);
@@ -322,6 +306,22 @@ export class OrchestratorAgent {
 
     const { max_tool_depth } = this.config.orchestrator;
 
+    // Detect time gap before adding the new message
+    let temporalContext = null;
+    const lastTs = this.conversationManager.getLastMessageTimestamp(chatId);
+    if (lastTs) {
+      const gapMs = Date.now() - lastTs;
+      const gapMinutes = Math.floor(gapMs / 60_000);
+      if (gapMinutes >= 30) {
+        const gapHours = Math.floor(gapMinutes / 60);
+        const gapText = gapHours >= 1
+          ? `${gapHours} hour(s)`
+          : `${gapMinutes} minute(s)`;
+        temporalContext = `[Time gap detected: ${gapText} since last message. User may be starting a new topic.]`;
+        logger.info(`Time gap detected for chat ${chatId}: ${gapText}`);
+      }
+    }
+
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
 
@@ -329,7 +329,7 @@ export class OrchestratorAgent {
     const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
     logger.debug(`Orchestrator conversation context: ${messages.length} messages, max_depth=${max_tool_depth}`);
 
-    const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth);
+    const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth, temporalContext);
 
     logger.info(`Orchestrator reply for chat ${chatId}: "${(reply || '').slice(0, 150)}"`);
 
@@ -738,6 +738,7 @@ export class OrchestratorAgent {
       callbacks: {
         onProgress: (text) => addActivity(text),
         onHeartbeat: (text) => job.addProgress(text),
+        onStats: (stats) => job.updateStats(stats),
         onUpdate, // Real bot onUpdate for tools (coder.js smart output needs message_id)
         onComplete: (result, parsedResult) => {
           logger.info(`[Worker ${job.id}] Completed — structured=${!!parsedResult?.structured}, result: "${(result || '').slice(0, 150)}"`);
@@ -840,8 +841,16 @@ export class OrchestratorAgent {
     for (const job of running) {
       const workerDef = WORKER_TYPES[job.workerType] || {};
       const dur = job.startedAt ? Math.round((now - job.startedAt) / 1000) : 0;
-      const recentActivity = job.progress.slice(-8).join(' → ');
-      lines.push(`- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s${recentActivity ? `\n  Recent: ${recentActivity}` : ''}`);
+      const stats = `${job.llmCalls} LLM calls, ${job.toolCalls} tools`;
+      const recentActivity = job.progress.slice(-5).join(' → ');
+      let line = `- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s [${stats}]`;
+      if (job.lastThinking) {
+        line += `\n  Thinking: "${job.lastThinking.slice(0, 150)}"`;
+      }
+      if (recentActivity) {
+        line += `\n  Recent: ${recentActivity}`;
+      }
+      lines.push(line);
     }
 
     // Queued/waiting jobs
@@ -881,20 +890,28 @@ export class OrchestratorAgent {
     return `[Active Workers]\n${lines.join('\n')}`;
   }
 
-  async _runLoop(chatId, messages, user, startDepth, maxDepth) {
+  async _runLoop(chatId, messages, user, startDepth, maxDepth, temporalContext = null) {
     const logger = getLogger();
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.info(`[Orchestrator] LLM call ${depth + 1}/${maxDepth} for chat ${chatId} — sending ${messages.length} messages`);
 
-      // Inject worker activity digest (transient — not stored in conversation history)
+      // Inject transient context messages (not stored in conversation history)
+      let workingMessages = [...messages];
+
+      // On first iteration, inject temporal context if present
+      if (depth === 0 && temporalContext) {
+        workingMessages = [{ role: 'user', content: `[Temporal Context]\n${temporalContext}` }, ...workingMessages];
+      }
+
+      // Inject worker activity digest
       const digest = this._buildWorkerDigest(chatId);
-      const workingMessages = digest
-        ? [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...messages]
-        : messages;
+      if (digest) {
+        workingMessages = [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...workingMessages];
+      }
 
       const response = await this.orchestratorProvider.chat({
-        system: this._getSystemPrompt(chatId, user),
+        system: this._getSystemPrompt(chatId, user, temporalContext),
         messages: workingMessages,
         tools: orchestratorToolDefinitions,
       });
@@ -923,6 +940,7 @@ export class OrchestratorAgent {
           logger.debug(`[Orchestrator] Tool input: ${JSON.stringify(block.input).slice(0, 300)}`);
           await this._sendUpdate(chatId, `⚡ ${summary}`);
 
+          const chatCallbacks = this._chatCallbacks.get(chatId) || {};
           const result = await executeOrchestratorTool(block.name, block.input, {
             chatId,
             jobManager: this.jobManager,
@@ -930,6 +948,8 @@ export class OrchestratorAgent {
             spawnWorker: (job) => this._spawnWorker(job),
             automationManager: this.automationManager,
             user,
+            sendReaction: chatCallbacks.sendReaction || null,
+            lastUserMessageId: chatCallbacks.lastUserMessageId || null,
           });
 
           logger.info(`[Orchestrator] Tool result for ${block.name}: ${JSON.stringify(result).slice(0, 200)}`);
@@ -978,11 +998,158 @@ export class OrchestratorAgent {
         return `Updating automation ${input.automation_id}`;
       case 'delete_automation':
         return `Deleting automation ${input.automation_id}`;
+      case 'send_reaction':
+        return `Reacting with ${input.emoji}`;
       default:
         return name;
     }
   }
 
+  /**
+   * Resume active chats after a restart.
+   * Checks recent conversations for pending items and sends follow-up messages.
+   * Called once from bot.js after startup.
+   */
+  async resumeActiveChats(sendMessageFn) {
+    const logger = getLogger();
+    const now = Date.now();
+    const MAX_AGE_MS = 24 * 60 * 60_000; // 24 hours
+
+    logger.info('[Orchestrator] Checking for active chats to resume...');
+
+    let resumeCount = 0;
+
+    for (const [chatId, messages] of this.conversationManager.conversations) {
+      // Skip internal life engine chat
+      if (chatId === '__life__') continue;
+
+      try {
+        // Find the last message with a timestamp
+        const lastMsg = [...messages].reverse().find(m => m.timestamp);
+        if (!lastMsg || !lastMsg.timestamp) continue;
+
+        const ageMs = now - lastMsg.timestamp;
+        if (ageMs > MAX_AGE_MS) continue;
+
+        // Calculate time gap for context
+        const gapMinutes = Math.floor(ageMs / 60_000);
+        const gapText = gapMinutes >= 60
+          ? `${Math.floor(gapMinutes / 60)} hour(s)`
+          : `${gapMinutes} minute(s)`;
+
+        // Build summarized history
+        const history = this.conversationManager.getSummarizedHistory(chatId);
+        if (history.length === 0) continue;
+
+        // Build resume prompt
+        const resumePrompt = `[System Restart] You just came back online after being offline for ${gapText}. Review the conversation above.\nIf there's something pending (unfinished task, follow-up, something to share), send a short natural message. If nothing's pending, respond with exactly: NONE`;
+
+        // Use minimal user object (private TG chats: chatId == userId)
+        const user = { id: chatId };
+
+        const response = await this.orchestratorProvider.chat({
+          system: this._getSystemPrompt(chatId, user),
+          messages: [
+            ...history,
+            { role: 'user', content: resumePrompt },
+          ],
+        });
+
+        const reply = (response.text || '').trim();
+
+        if (reply && reply !== 'NONE') {
+          await sendMessageFn(chatId, reply);
+          this.conversationManager.addMessage(chatId, 'assistant', reply);
+          resumeCount++;
+          logger.info(`[Orchestrator] Resume message sent to chat ${chatId}`);
+        } else {
+          logger.debug(`[Orchestrator] No resume needed for chat ${chatId}`);
+        }
+
+        // Small delay between chats to avoid rate limiting
+        await new Promise(r => setTimeout(r, 1000));
+      } catch (err) {
+        logger.error(`[Orchestrator] Resume failed for chat ${chatId}: ${err.message}`);
+      }
+    }
+
+    logger.info(`[Orchestrator] Resume check complete — ${resumeCount} message(s) sent`);
+  }
+
+  /**
+   * Deliver pending shares from the life engine to active chats proactively.
+   * Called periodically from bot.js.
+   */
+  async deliverPendingShares(sendMessageFn) {
+    const logger = getLogger();
+
+    if (!this.shareQueue) return;
+
+    const pending = this.shareQueue.getPending(null, 5);
+    if (pending.length === 0) return;
+
+    const now = Date.now();
+    const MAX_AGE_MS = 24 * 60 * 60_000;
+
+    // Find active chats (last message within 24h)
+    const activeChats = [];
+    for (const [chatId, messages] of this.conversationManager.conversations) {
+      if (chatId === '__life__') continue;
+      const lastMsg = [...messages].reverse().find(m => m.timestamp);
+      if (lastMsg && lastMsg.timestamp && (now - lastMsg.timestamp) < MAX_AGE_MS) {
+        activeChats.push(chatId);
+      }
+    }
+
+    if (activeChats.length === 0) {
+      logger.debug('[Orchestrator] No active chats for share delivery');
+      return;
+    }
+
+    logger.info(`[Orchestrator] Delivering ${pending.length} pending share(s) to ${activeChats.length} active chat(s)`);
+
+    // Cap at 3 chats per cycle to avoid spam
+    const targetChats = activeChats.slice(0, 3);
+
+    for (const chatId of targetChats) {
+      try {
+        const history = this.conversationManager.getSummarizedHistory(chatId);
+        const user = { id: chatId };
+
+        // Build shares into a prompt
+        const sharesText = pending.map((s, i) => `${i + 1}. [${s.source}] ${s.content}`).join('\n');
+
+        const sharePrompt = `[Proactive Share] You have some discoveries and thoughts you'd like to share naturally. Here they are:\n\n${sharesText}\n\nWeave one or more of these into a short, natural message. Don't be forced — pick what feels relevant to this user and conversation. If none feel right for this chat, respond with exactly: NONE`;
+
+        const response = await this.orchestratorProvider.chat({
+          system: this._getSystemPrompt(chatId, user),
+          messages: [
+            ...history,
+            { role: 'user', content: sharePrompt },
+          ],
+        });
+
+        const reply = (response.text || '').trim();
+
+        if (reply && reply !== 'NONE') {
+          await sendMessageFn(chatId, reply);
+          this.conversationManager.addMessage(chatId, 'assistant', reply);
+          logger.info(`[Orchestrator] Proactive share delivered to chat ${chatId}`);
+
+          // Mark shares as delivered for this user
+          for (const item of pending) {
+            this.shareQueue.markShared(item.id, chatId);
+          }
+        }
+
+        // Delay between chats
+        await new Promise(r => setTimeout(r, 2000));
+      } catch (err) {
+        logger.error(`[Orchestrator] Share delivery failed for chat ${chatId}: ${err.message}`);
+      }
+    }
+  }
+
   /** Background persona extraction. */
   async _extractPersonaBackground(userMessage, reply, user) {
     const logger = getLogger();