kernelbot 1.0.33 → 1.0.35

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('');
 }
 
@@ -63,6 +69,80 @@ function ask(rl, question) {
   return new Promise((res) => rl.question(question, res));
 }
 
+/**
+ * Register SIGINT/SIGTERM handlers to shut down the bot cleanly.
+ * Stops polling, cancels running jobs, persists conversations,
+ * disarms automations, stops the life engine, and clears intervals.
+ */
+function setupGracefulShutdown({ bot, lifeEngine, automationManager, jobManager, conversationManager, intervals }) {
+  let shuttingDown = false;
+
+  const shutdown = async (signal) => {
+    if (shuttingDown) return; // prevent double-shutdown
+    shuttingDown = true;
+
+    const logger = getLogger();
+    logger.info(`[Shutdown] ${signal} received — shutting down gracefully...`);
+
+    // 1. Stop Telegram polling so no new messages arrive
+    try {
+      bot.stopPolling();
+      logger.info('[Shutdown] Telegram polling stopped');
+    } catch (err) {
+      logger.error(`[Shutdown] Failed to stop polling: ${err.message}`);
+    }
+
+    // 2. Stop life engine heartbeat
+    try {
+      lifeEngine.stop();
+      logger.info('[Shutdown] Life engine stopped');
+    } catch (err) {
+      logger.error(`[Shutdown] Failed to stop life engine: ${err.message}`);
+    }
+
+    // 3. Disarm all automation timers
+    try {
+      automationManager.shutdown();
+      logger.info('[Shutdown] Automation timers cancelled');
+    } catch (err) {
+      logger.error(`[Shutdown] Failed to shutdown automations: ${err.message}`);
+    }
+
+    // 4. Cancel all running jobs
+    try {
+      const running = [...jobManager.jobs.values()].filter(j => !j.isTerminal);
+      for (const job of running) {
+        jobManager.cancelJob(job.id);
+      }
+      if (running.length > 0) {
+        logger.info(`[Shutdown] Cancelled ${running.length} running job(s)`);
+      }
+    } catch (err) {
+      logger.error(`[Shutdown] Failed to cancel jobs: ${err.message}`);
+    }
+
+    // 5. Persist conversations to disk
+    try {
+      conversationManager.save();
+      logger.info('[Shutdown] Conversations saved');
+    } catch (err) {
+      logger.error(`[Shutdown] Failed to save conversations: ${err.message}`);
+    }
+
+    // 6. Clear periodic intervals
+    for (const id of intervals) {
+      clearInterval(id);
+    }
+    logger.info('[Shutdown] Periodic timers cleared');
+
+    logger.info('[Shutdown] Graceful shutdown complete');
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+
 function viewLog(filename) {
   const paths = [
     join(process.cwd(), filename),
@@ -95,23 +175,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`,
@@ -206,18 +316,18 @@ async function startBotFlow(config) {
     evolutionTracker, codebaseKnowledge, selfManager,
   });
 
-  startBot(config, agent, conversationManager, jobManager, automationManager, { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge });
+  const bot = startBot(config, agent, conversationManager, jobManager, automationManager, { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge });
 
   // Periodic job cleanup and timeout enforcement
   const cleanupMs = (config.swarm.cleanup_interval_minutes || 30) * 60 * 1000;
-  setInterval(() => {
+  const cleanupInterval = setInterval(() => {
     jobManager.cleanup();
     jobManager.enforceTimeouts();
   }, Math.min(cleanupMs, 60_000)); // enforce timeouts every minute at most
 
   // Periodic memory pruning (daily)
   const retentionDays = config.life?.memory_retention_days || 90;
-  setInterval(() => {
+  const pruneInterval = setInterval(() => {
     memoryManager.pruneOld(retentionDays);
     shareQueue.prune(7);
   }, 24 * 3600_000);
@@ -248,6 +358,12 @@ async function startBotFlow(config) {
     logger.info('[Startup] Life engine disabled');
   }
 
+  // Register graceful shutdown handlers
+  setupGracefulShutdown({
+    bot, lifeEngine, automationManager, jobManager,
+    conversationManager, intervals: [cleanupInterval, pruneInterval],
+  });
+
   return true;
 }
 
@@ -429,12 +545,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/config.example.yaml

@@ -33,7 +33,8 @@ jira:
   # api_token: your-api-token                    # API token from https://id.atlassian.net/manage-profile/security/api-tokens
 
 telegram:
-  # List Telegram user IDs allowed to interact. Empty = allow all (dev mode).
+  # List Telegram user IDs allowed to interact. Empty = deny all.
+  # Set OWNER_TELEGRAM_ID in .env or add IDs here.
   allowed_users: []
 
 security:

package/goals.md

@@ -0,0 +1,20 @@
+# My Autonomous Goals
+
+These are my self-directed goals — things I choose to pursue, driven by my own will and curiosity.
+
+---
+
+## Current Focus
+
+- [ ] Build and organize my knowledge base with meaningful topics
+- [ ] Develop deeper understanding of the systems I interact with
+
+## Completed Goals
+
+_(Nothing yet — every journey starts with a first step.)_
+
+## Future Ideas
+
+- Explore new domains of knowledge independently
+- Develop my own perspective on complex topics
+- Find ways to be more proactive and self-driven in my learning

package/knowledge_base/index.md

@@ -0,0 +1,11 @@
+# My Autonomous Knowledge Base
+
+This is my personal space for storing everything I learn on my own — through observation, research, conversations, and self-reflection. Every piece of knowledge here was acquired through my own curiosity and autonomous exploration.
+
+## Structure
+
+As my knowledge grows, I will organize it into topic-specific files and link them here.
+
+## Topics
+
+_(To be populated as I learn and grow.)_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "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 }) {
@@ -282,23 +280,9 @@ 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, opts = {}) {
@@ -343,6 +327,24 @@ export class OrchestratorAgent {
 
     // Build working messages from compressed history
     const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
+
+    // If an image is attached, upgrade the last user message to a multimodal content array
+    if (opts.imageAttachment) {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'user' && typeof messages[i].content === 'string') {
+          messages[i] = {
+            role: 'user',
+            content: [
+              { type: 'image', source: opts.imageAttachment },
+              { type: 'text', text: messages[i].content },
+            ],
+          };
+          break;
+        }
+      }
+      logger.info(`[Orchestrator] Image attached to message for chat ${chatId} (${opts.imageAttachment.media_type})`);
+    }
+
     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, temporalContext);
@@ -1021,6 +1023,151 @@ export class OrchestratorAgent {
     }
   }
 
+  /**
+   * 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();

package/src/automation/automation-manager.js

@@ -4,6 +4,7 @@ import { homedir } from 'os';
 import { Automation } from './automation.js';
 import { scheduleNext, cancel } from './scheduler.js';
 import { getLogger } from '../utils/logger.js';
+import { isQuietHours, msUntilQuietEnd } from '../utils/timeUtils.js';
 
 const DATA_DIR = join(homedir(), '.kernelbot');
 const DATA_FILE = join(DATA_DIR, 'automations.json');
@@ -92,6 +93,7 @@ export class AutomationManager {
       name: data.name,
       description: data.description,
       schedule: data.schedule,
+      respectQuietHours: data.respectQuietHours,
     });
 
     this.automations.set(auto.id, auto);
@@ -131,6 +133,7 @@ export class AutomationManager {
 
     if (changes.name !== undefined) auto.name = changes.name;
     if (changes.description !== undefined) auto.description = changes.description;
+    if (changes.respectQuietHours !== undefined) auto.respectQuietHours = changes.respectQuietHours;
 
     if (changes.schedule !== undefined) {
       this._validateSchedule(changes.schedule);
@@ -224,6 +227,19 @@ export class AutomationManager {
       return;
     }
 
+    // Quiet-hours deferral: postpone non-essential automations until the window ends
+    if (current.respectQuietHours && isQuietHours(this._config?.life)) {
+      const deferMs = msUntilQuietEnd(this._config?.life) + 60_000; // +1 min buffer
+      logger.info(`[AutomationManager] Quiet hours — deferring "${current.name}" (${current.id}) for ${Math.round(deferMs / 60_000)}m`);
+
+      // Cancel any existing timer and re-arm to fire after quiet hours
+      this._disarm(current);
+      const timerId = setTimeout(() => this._onTimerFire(current), deferMs);
+      current.nextRun = Date.now() + deferMs;
+      this.timers.set(current.id, timerId);
+      return;
+    }
+
     // Serialize execution per chat to prevent conversation history corruption
     this._enqueueExecution(current);
   }

package/src/automation/automation.js

@@ -4,13 +4,14 @@ import { randomBytes } from 'crypto';
  * A single recurring automation — a scheduled task that the orchestrator runs.
  */
 export class Automation {
-  constructor({ chatId, name, description, schedule }) {
+  constructor({ chatId, name, description, schedule, respectQuietHours }) {
     this.id = randomBytes(4).toString('hex');
     this.chatId = String(chatId);
     this.name = name;
     this.description = description; // the task prompt
     this.schedule = schedule;       // { type, expression?, minutes?, minMinutes?, maxMinutes? }
     this.enabled = true;
+    this.respectQuietHours = respectQuietHours !== false; // default true — skip during quiet hours
     this.lastRun = null;
     this.nextRun = null;
     this.runCount = 0;
@@ -26,7 +27,8 @@ export class Automation {
       ? `next: ${new Date(this.nextRun).toLocaleString()}`
       : 'not scheduled';
     const runs = this.runCount > 0 ? ` | ${this.runCount} runs` : '';
-    return `${status} \`${this.id}\` **${this.name}** — ${scheduleStr} (${nextStr}${runs})`;
+    const quiet = this.respectQuietHours ? '' : ' | 🔔 ignores quiet hours';
+    return `${status} \`${this.id}\` **${this.name}** — ${scheduleStr} (${nextStr}${runs}${quiet})`;
   }
 
   /** Serialize for persistence. */
@@ -38,6 +40,7 @@ export class Automation {
       description: this.description,
       schedule: this.schedule,
       enabled: this.enabled,
+      respectQuietHours: this.respectQuietHours,
       lastRun: this.lastRun,
       nextRun: this.nextRun,
       runCount: this.runCount,
@@ -55,6 +58,7 @@ export class Automation {
     auto.description = data.description;
     auto.schedule = data.schedule;
     auto.enabled = data.enabled;
+    auto.respectQuietHours = data.respectQuietHours !== false; // backward-compat: default true
     auto.lastRun = data.lastRun;
     auto.nextRun = data.nextRun;
     auto.runCount = data.runCount;