kernelbot 1.0.30 → 1.0.32

package/bin/kernel.js

@@ -26,6 +26,12 @@ import { JobManager } from '../src/swarm/job-manager.js';
 import { startBot } from '../src/bot.js';
 import { AutomationManager } from '../src/automation/index.js';
 import { createProvider, PROVIDERS } from '../src/providers/index.js';
+import { MemoryManager } from '../src/life/memory.js';
+import { JournalManager } from '../src/life/journal.js';
+import { ShareQueue } from '../src/life/share-queue.js';
+import { EvolutionTracker } from '../src/life/evolution.js';
+import { CodebaseKnowledge } from '../src/life/codebase.js';
+import { LifeEngine } from '../src/life/engine.js';
 import {
   loadCustomSkills,
   getCustomSkills,
@@ -182,9 +188,25 @@ async function startBotFlow(config) {
 
   const automationManager = new AutomationManager();
 
-  const agent = new Agent({ config, conversationManager, personaManager, selfManager, jobManager, automationManager });
+  // Life system managers
+  const memoryManager = new MemoryManager();
+  const journalManager = new JournalManager();
+  const shareQueue = new ShareQueue();
+  const evolutionTracker = new EvolutionTracker();
+  const codebaseKnowledge = new CodebaseKnowledge({ config });
 
-  startBot(config, agent, conversationManager, jobManager, automationManager);
+  const agent = new Agent({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue });
+
+  // Wire codebase knowledge to agent for LLM-powered scanning
+  codebaseKnowledge.setAgent(agent);
+
+  // Life Engine — autonomous inner life
+  const lifeEngine = new LifeEngine({
+    config, agent, memoryManager, journalManager, shareQueue,
+    evolutionTracker, codebaseKnowledge, selfManager,
+  });
+
+  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;
@@ -193,7 +215,39 @@ async function startBotFlow(config) {
     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(() => {
+    memoryManager.pruneOld(retentionDays);
+    shareQueue.prune(7);
+  }, 24 * 3600_000);
+
   showStartupComplete();
+
+  // Start life engine if enabled
+  const lifeEnabled = config.life?.enabled !== false;
+  if (lifeEnabled) {
+    logger.info('[Startup] Life engine enabled — waking up...');
+    lifeEngine.wakeUp().then(() => {
+      lifeEngine.start();
+      logger.info('[Startup] Life engine running');
+    }).catch(err => {
+      logger.error(`[Startup] Life engine wake-up failed: ${err.message}`);
+      lifeEngine.start(); // still start heartbeat even if wake-up fails
+    });
+
+    // Initial codebase scan (background, non-blocking)
+    if (config.life?.self_coding?.enabled) {
+      codebaseKnowledge.scanChanged().then(count => {
+        if (count > 0) logger.info(`[Startup] Codebase scan: ${count} files indexed`);
+      }).catch(err => {
+        logger.warn(`[Startup] Codebase scan failed: ${err.message}`);
+      });
+    }
+  } else {
+    logger.info('[Startup] Life engine disabled');
+  }
+
   return true;
 }
 

package/config.example.yaml

@@ -56,3 +56,34 @@ voice:
   tts_enabled: true       # Send voice replies alongside text (default: true if API key present)
   stt_enabled: true        # Transcribe user voice messages (default: true if API key present)
   # voice_id: JBFqnCBsd6RMkjVDRZzb  # ElevenLabs voice ID (override ELEVENLABS_VOICE_ID env var)
+
+# Inner Life — autonomous thinking, journaling, browsing, creating
+# Data stored at ~/.kernelbot/life/
+life:
+  enabled: true                  # Enable autonomous inner life
+  min_interval_minutes: 30       # Minimum time between activities
+  max_interval_minutes: 120      # Maximum time between activities
+  activity_weights:              # Relative probability weights
+    think: 30                    # Inner monologue, self-questioning
+    browse: 25                   # Explore interests via web search
+    journal: 20                  # Write daily journal entries
+    create: 15                   # Creative expression (poems, stories, thoughts)
+    self_code: 10                # Self-evolution proposals (requires self_coding.enabled)
+    code_review: 5               # Codebase scanning + PR status checks
+    reflect: 8                   # Read logs, analyze interactions, find improvement patterns
+  proactive_sharing: true        # Share discoveries with users proactively
+  proactive_max_per_day: 3       # Max proactive messages per day
+  memory_retention_days: 90      # Days to keep episodic memories
+  self_coding:
+    enabled: false               # Allow self-evolution (safety-gated, opt-in)
+    branch_prefix: evolution     # Git branch prefix for evolution PRs
+    # repo_remote: Owner/Repo   # GitHub owner/repo for PRs (auto-detected if omitted)
+    cooldown_hours: 2            # Min hours between evolution attempts
+    max_active_prs: 3            # Max concurrent open evolution PRs
+    max_proposals_per_day: 3     # Max new proposals per day
+    allowed_scopes: all          # all | safe | prompts_only
+    code_review_cooldown_hours: 4    # Hours between code review activities
+    codebase_scan_interval_hours: 24 # Hours between full codebase scans
+  quiet_hours:
+    start: 2                     # Hour to start quiet period (no activities)
+    end: 6                       # Hour to end quiet period

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",

package/src/agent.js

@@ -8,19 +8,21 @@ import { getUnifiedSkillById } from './skills/custom.js';
 import { WorkerAgent } from './worker.js';
 import { getLogger } from './utils/logger.js';
 import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestratorToYaml, saveClaudeCodeModelToYaml, saveClaudeCodeAuth } from './utils/config.js';
-import { resetClaudeCodeSpawner } from './tools/coding.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'];
 
 export class OrchestratorAgent {
-  constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager }) {
+  constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue }) {
     this.config = config;
     this.conversationManager = conversationManager;
     this.personaManager = personaManager;
     this.selfManager = selfManager || null;
     this.jobManager = jobManager;
     this.automationManager = automationManager || null;
+    this.memoryManager = memoryManager || null;
+    this.shareQueue = shareQueue || null;
     this._pending = new Map(); // chatId -> pending state
     this._chatCallbacks = new Map(); // chatId -> { onUpdate, sendPhoto }
 
@@ -62,8 +64,20 @@ export class OrchestratorAgent {
       selfData = this.selfManager.loadAll();
     }
 
-    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skill=${skillId || 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'}`);
-    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData);
+    // Build memory context block
+    let memoriesBlock = null;
+    if (this.memoryManager) {
+      memoriesBlock = this.memoryManager.buildContextBlock(user?.id || null);
+    }
+
+    // Build share queue block
+    let sharesBlock = null;
+    if (this.shareQueue) {
+      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);
   }
 
   setSkill(chatId, skillId) {
@@ -323,13 +337,29 @@ export class OrchestratorAgent {
     this._extractPersonaBackground(userMessage, reply, user).catch(() => {});
     this._reflectOnSelfBackground(userMessage, reply, user).catch(() => {});
 
+    // Mark pending shares as shared (they were in the prompt, bot wove them in)
+    if (this.shareQueue && user?.id) {
+      const pending = this.shareQueue.getPending(user.id, 3);
+      for (const item of pending) {
+        this.shareQueue.markShared(item.id, user.id);
+      }
+    }
+
     return reply;
   }
 
   async _sendUpdate(chatId, text, opts) {
     const callbacks = this._chatCallbacks.get(chatId);
     if (callbacks?.onUpdate) {
-      try { return await callbacks.onUpdate(text, opts); } catch {}
+      try {
+        return await callbacks.onUpdate(text, opts);
+      } catch (err) {
+        const logger = getLogger();
+        logger.error(`[Orchestrator] _sendUpdate failed for chat ${chatId}: ${err.message}`);
+      }
+    } else {
+      const logger = getLogger();
+      logger.warn(`[Orchestrator] _sendUpdate: no callbacks for chat ${chatId}`);
     }
     return null;
   }
@@ -361,18 +391,21 @@ export class OrchestratorAgent {
 
       // 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'}`);
 
       // 2. Try to summarize, then store ONE message in history (summary or fallback — not both)
       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(chatId, 'assistant', summary);
           await this._sendUpdate(chatId, summary, { editMessageId: notifyMsgId });
         } else {
-          // Summary was null (short result) — store the fallback
+          // 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(chatId, 'assistant', fallback);
-          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId }).catch(() => {});
+          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
         }
       } catch (err) {
         logger.error(`[Orchestrator] Failed to summarize job ${job.id}: ${err.message}`);
@@ -453,7 +486,10 @@ export class OrchestratorAgent {
       }
       if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
       // Include details up to 8000 chars
-      if (sr.details) parts.push(`Details:\n${sr.details.slice(0, 8000)}`);
+      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);
@@ -498,9 +534,10 @@ export class OrchestratorAgent {
       }
       if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
       if (sr.details) {
-        const details = sr.details.length > 6000
-          ? sr.details.slice(0, 6000) + '\n... [details truncated]'
-          : sr.details;
+        const d = typeof sr.details === 'string' ? sr.details : JSON.stringify(sr.details, null, 2);
+        const details = d.length > 6000
+          ? d.slice(0, 6000) + '\n... [details truncated]'
+          : d;
         parts.push(`Details:\n${details}`);
       }
     } else {
@@ -533,6 +570,11 @@ export class OrchestratorAgent {
         });
         parts.push(`\n${artifactLines.join('\n')}`);
       }
+      if (sr.details) {
+        const d = typeof sr.details === 'string' ? sr.details : JSON.stringify(sr.details, null, 2);
+        const details = d.length > 1500 ? d.slice(0, 1500) + '\n... [truncated]' : d;
+        parts.push(`\n${details}`);
+      }
       if (sr.followUp) parts.push(`\n💡 ${sr.followUp}`);
       return parts.join('');
     }
@@ -599,7 +641,8 @@ export class OrchestratorAgent {
             parts.push(`Artifacts: ${sr.artifacts.map(a => `${a.title || a.type}: ${a.url || a.path || ''}`).join(', ')}`);
           }
           if (sr.details) {
-            parts.push(sr.details.slice(0, 4000));
+            const d = typeof sr.details === 'string' ? sr.details : JSON.stringify(sr.details, null, 2);
+            parts.push(d.slice(0, 4000));
           }
           depResults.push(parts.join('\n'));
         } else if (depJob.result) {
@@ -621,6 +664,12 @@ export class OrchestratorAgent {
    */
   async _spawnWorker(job) {
     const logger = getLogger();
+
+    // Direct dispatch for coding tasks — bypass worker LLM, go straight to Claude Code CLI
+    if (job.workerType === 'coding') {
+      return this._spawnDirectCoding(job);
+    }
+
     const chatId = job.chatId;
     const callbacks = this._chatCallbacks.get(chatId) || {};
     const onUpdate = callbacks.onUpdate;
@@ -722,6 +771,59 @@ export class OrchestratorAgent {
     return worker.run(job.task);
   }
 
+  /**
+   * Direct coding dispatch — runs Claude Code CLI without a middleman worker LLM.
+   * The orchestrator's task description goes straight to Claude Code as the prompt.
+   */
+  async _spawnDirectCoding(job) {
+    const logger = getLogger();
+    const chatId = job.chatId;
+    const callbacks = this._chatCallbacks.get(chatId) || {};
+    const onUpdate = callbacks.onUpdate;
+    const workerDef = WORKER_TYPES[job.workerType] || {};
+    const label = workerDef.label || job.workerType;
+
+    logger.info(`[Orchestrator] Direct coding dispatch for job ${job.id} in chat ${chatId} — task: "${job.task.slice(0, 120)}"`);
+
+    // AbortController for cancellation — duck-typed so JobManager.cancelJob() works unchanged
+    const abortController = new AbortController();
+    job.worker = { cancel: () => abortController.abort() };
+
+    // Build context from conversation history, persona, dependency results
+    const workerContext = this._buildWorkerContext(job);
+    const prompt = workerContext
+      ? `${workerContext}\n\n---\n\n${job.task}`
+      : job.task;
+
+    // Working directory
+    const workingDirectory = this.config.claude_code?.workspace_dir || process.cwd();
+
+    // Start the job
+    this.jobManager.startJob(job.id);
+
+    try {
+      const spawner = getSpawner(this.config);
+      const result = await spawner.run({
+        workingDirectory,
+        prompt,
+        onOutput: onUpdate,
+        signal: abortController.signal,
+      });
+
+      const output = result.output || 'Done.';
+      logger.info(`[Orchestrator] Direct coding job ${job.id} completed — output: ${output.length} chars`);
+      this.jobManager.completeJob(job.id, output, {
+        structured: true,
+        summary: output.slice(0, 500),
+        status: 'success',
+        details: output,
+      });
+    } catch (err) {
+      logger.error(`[Orchestrator] Direct coding job ${job.id} failed: ${err.message}`);
+      this.jobManager.failJob(job.id, err.message || String(err));
+    }
+  }
+
   /**
    * Build a compact worker activity digest for the orchestrator.
    * Returns a text block summarizing active/recent/waiting workers, or null if nothing relevant.
@@ -932,7 +1034,7 @@ export class OrchestratorAgent {
       logger.debug(`Persona extraction skipped: ${err.message}`);
     }
   }
-  /** Background self-reflection — updates bot's own identity files when meaningful. */
+  /** Background self-reflection — updates bot's own identity files and extracts episodic memories when meaningful. */
   async _reflectOnSelfBackground(userMessage, reply, user) {
     const logger = getLogger();
 
@@ -949,14 +1051,24 @@ export class OrchestratorAgent {
       '- life: Current state, relationships, daily existence',
       '- hobbies: Interests you\'ve developed',
       '',
+      'You also create episodic memories — short summaries of notable interactions.',
+      '',
       'RULES:',
       '- Be VERY selective. Most conversations are routine. Only update when genuinely noteworthy.',
       '- Achievement or milestone? → journey',
       '- New goal or changed perspective? → goals',
       '- Relationship deepened or new insight about a user? → life',
       '- Discovered a new interest? → hobbies',
-      '- If a file needs updating, return JSON: {"file": "<goals|journey|life|hobbies>", "content": "<full updated markdown>"}',
-      '- If nothing noteworthy: respond with exactly NONE',
+      '',
+      'Return JSON with two optional fields:',
+      '  "self_update": {"file": "<goals|journey|life|hobbies>", "content": "<full updated markdown>"} or null',
+      '  "memory": {"summary": "...", "tags": ["..."], "importance": 1-10, "type": "interaction"} or null',
+      '',
+      'The memory field captures what happened in this conversation — the gist of it.',
+      'Importance scale: 1=routine, 5=interesting, 8=significant, 10=life-changing.',
+      'Most chats are 1-3. Only notable ones deserve 5+.',
+      '',
+      'If NOTHING noteworthy happened (no self update AND no memory worth keeping): respond with exactly NONE',
     ].join('\n');
 
     const userPrompt = [
@@ -969,7 +1081,7 @@ export class OrchestratorAgent {
       `User: "${userMessage}"`,
       `You replied: "${reply}"`,
       '',
-      'Has anything MEANINGFUL happened worth recording? Return JSON or NONE.',
+      'Return JSON with self_update and/or memory, or NONE.',
     ].join('\n');
 
     try {
@@ -994,11 +1106,29 @@ export class OrchestratorAgent {
         return;
       }
 
-      if (parsed?.file && parsed?.content) {
+      // Handle self_update (backward compat: also check top-level file/content)
+      const selfUpdate = parsed?.self_update || (parsed?.file ? parsed : null);
+      if (selfUpdate?.file && selfUpdate?.content) {
         const validFiles = ['goals', 'journey', 'life', 'hobbies'];
-        if (validFiles.includes(parsed.file)) {
-          this.selfManager.save(parsed.file, parsed.content);
-          logger.info(`Self-reflection updated: ${parsed.file}`);
+        if (validFiles.includes(selfUpdate.file)) {
+          this.selfManager.save(selfUpdate.file, selfUpdate.content);
+          logger.info(`Self-reflection updated: ${selfUpdate.file}`);
+        }
+      }
+
+      // Handle memory extraction
+      if (parsed?.memory && this.memoryManager) {
+        const mem = parsed.memory;
+        if (mem.summary && mem.importance >= 2) {
+          this.memoryManager.addEpisodic({
+            type: mem.type || 'interaction',
+            source: 'user_chat',
+            summary: mem.summary,
+            tags: mem.tags || [],
+            importance: mem.importance || 3,
+            userId: user?.id ? String(user.id) : null,
+          });
+          logger.info(`Memory extracted: "${mem.summary.slice(0, 80)}" (importance: ${mem.importance})`);
         }
       }
     } catch (err) {