kernelbot 1.0.30 → 1.0.33

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.33",
   "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 }
 
@@ -47,7 +49,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;
@@ -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'} | temporal=${temporalContext ? 'yes' : 'none'}`);
+    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext);
   }
 
   setSkill(chatId, skillId) {
@@ -287,13 +301,13 @@ export class OrchestratorAgent {
     return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
   }
 
-  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);
@@ -308,6 +322,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);
 
@@ -315,7 +345,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)}"`);
 
@@ -323,13 +353,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 +407,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 +502,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 +550,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 +586,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 +657,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 +680,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;
@@ -689,6 +754,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)}"`);
@@ -722,6 +788,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.
@@ -738,8 +857,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
@@ -779,20 +906,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,
       });
@@ -821,6 +956,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,
@@ -828,6 +964,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)}`);
@@ -876,6 +1014,8 @@ 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;
     }
@@ -932,7 +1072,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 +1089,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 +1119,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 +1144,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) {