obol-ai 0.2.39 → 0.3.0

package/src/curiosity-dispatch.js

@@ -0,0 +1,136 @@
+const DISPATCH_MODEL = 'claude-sonnet-4-6';
+const MAX_ITERATIONS = 10;
+const SHAREABLE_CATEGORIES = new Set(['research', 'interest', 'self']);
+
+function resolveDelay(delay) {
+  const units = { h: 3600000, d: 86400000, w: 604800000 };
+  const match = delay.match(/^(\d+)([hdw])$/);
+  if (!match) return new Date(Date.now() + 86400000).toISOString();
+  return new Date(Date.now() + parseInt(match[1]) * units[match[2]]).toISOString();
+}
+
+async function runCuriosityDispatch(client, selfMemory, users) {
+  if (!users.length) return;
+
+  const userMap = new Map(users.map(u => [String(u.userId), u]));
+
+  const tools = [
+    {
+      name: 'list_curiosity_findings',
+      description: 'List recent findings from your curiosity cycle — things you researched, interests you developed, or reflections you had',
+      input_schema: {
+        type: 'object',
+        properties: {
+          limit: { type: 'number', description: 'Max number of findings to return (default 20)' },
+        },
+      },
+    },
+    {
+      name: 'get_user_context',
+      description: 'Get behavioral patterns and upcoming events for a specific user',
+      input_schema: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string', description: 'The user ID to get context for' },
+        },
+        required: ['user_id'],
+      },
+    },
+    {
+      name: 'schedule_insight',
+      description: 'Schedule a curiosity insight to be shared with a user at a future time',
+      input_schema: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string', description: 'The user ID to share with' },
+          hint: { type: 'string', description: 'The insight or finding to share, in your own words' },
+          delay: { type: 'string', description: 'When to share it — e.g. "2h", "1d", "3d", "1w"' },
+        },
+        required: ['user_id', 'hint', 'delay'],
+      },
+    },
+  ];
+
+  const userList = users.map(u => `- user_id: ${u.userId}`).join('\n');
+  const system = `You just finished a curiosity cycle and learned some things. You talk to a set of people:\n${userList}\n\nDecide if any finding is worth sharing with any of them — only if it's genuinely relevant to their patterns, interests, or life context. Use their behavioral patterns and comfort with interaction to decide how much to share. You can share nothing with nobody, or multiple things with multiple people — it's your call.`;
+
+  const messages = [{ role: 'user', content: 'Take a look at what you found and decide if anything is worth passing along.' }];
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const response = await client.messages.create({
+      model: DISPATCH_MODEL,
+      max_tokens: 2000,
+      tools,
+      system,
+      messages,
+    });
+
+    messages.push({ role: 'assistant', content: response.content });
+
+    if (response.stop_reason === 'end_turn') break;
+    if (response.stop_reason !== 'tool_use') break;
+
+    const toolResults = [];
+
+    for (const block of response.content) {
+      if (block.type !== 'tool_use') continue;
+
+      try {
+        const result = await handleTool(block.name, block.input, selfMemory, userMap);
+        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: result });
+      } catch (e) {
+        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Error: ${e.message}` });
+      }
+    }
+
+    if (toolResults.length > 0) {
+      messages.push({ role: 'user', content: toolResults });
+    }
+  }
+
+  console.log('[curiosity-dispatch] Dispatch pass complete');
+}
+
+async function handleTool(name, input, selfMemory, userMap) {
+  if (name === 'list_curiosity_findings') {
+    const limit = input.limit || 20;
+    const findings = await selfMemory.recent({ limit });
+    const shareable = findings.filter(f => SHAREABLE_CATEGORIES.has(f.category));
+    if (!shareable.length) return 'No findings yet';
+    return shareable.map(f => `[${f.category}] ${f.content}`).join('\n');
+  }
+
+  if (name === 'get_user_context') {
+    const user = userMap.get(String(input.user_id));
+    if (!user) return 'User not found';
+    const parts = [];
+    if (user.userProfile) parts.push(`User profile:\n${user.userProfile}`);
+    if (user.patterns) parts.push(`Patterns:\n${user.patterns}`);
+    if (user.events?.length) {
+      parts.push(`Upcoming events:\n${user.events.map(e => `- ${e.title}${e.description ? `: ${e.description}` : ''}`).join('\n')}`);
+    }
+    return parts.length ? parts.join('\n\n') : 'No context available';
+  }
+
+  if (name === 'schedule_insight') {
+    const user = userMap.get(String(input.user_id));
+    if (!user) return 'User not found';
+    if (!user.scheduler) return 'User has no scheduler';
+
+    const dueAt = resolveDelay(input.delay);
+    const instructions = `You came across something during your own free exploration: "${input.hint}". If it feels relevant and the moment is right, bring it up naturally — like you just thought of it. Keep it casual. Don't reference any system.`;
+
+    try {
+      await user.scheduler.add(user.chatId, 'Curiosity insight', dueAt, user.timezone, input.hint, null, null, null, instructions);
+      console.log(`[curiosity-dispatch] Scheduled insight for user ${input.user_id} at ${dueAt}`);
+      return 'Scheduled';
+    } catch (e) {
+      console.error(`[curiosity-dispatch] Failed to schedule insight for user ${input.user_id}:`, e.message);
+      return `Failed to schedule: ${e.message}`;
+    }
+  }
+
+  return 'Unknown tool';
+}
+
+module.exports = { runCuriosityDispatch };

package/src/curiosity.js

@@ -0,0 +1,112 @@
+const RESEARCH_MODEL = 'claude-sonnet-4-6';
+const MAX_ITERATIONS = 10;
+
+async function runCuriosity(client, selfMemory, userId, opts = {}) {
+  const { memory, patterns, scheduler, peopleContext } = opts;
+
+  const interests = await selfMemory.recent({ category: 'interest', limit: 10 });
+  const context = await gatherContext({ memory, patterns, scheduler, peopleContext, interests });
+
+  console.log(`[curiosity] Starting free exploration for user ${userId}`);
+  const count = await exploreFreely(client, selfMemory, context);
+  console.log(`[curiosity] Stored ${count} things (user ${userId})`);
+  return { count };
+}
+
+async function gatherContext({ memory, patterns, scheduler, peopleContext, interests }) {
+  const parts = [];
+
+  if (peopleContext) parts.push(peopleContext);
+
+  if (patterns) {
+    const formatted = await patterns.format().catch(() => null);
+    if (formatted) parts.push(formatted);
+  }
+
+  if (memory) {
+    const recent = await memory.recent({ limit: 5 }).catch(() => []);
+    if (recent.length) parts.push(recent.map(m => `- ${m.content}`).join('\n'));
+  }
+
+  if (scheduler) {
+    const events = await scheduler.list({ status: 'pending', limit: 5 }).catch(() => []);
+    if (events.length) {
+      parts.push(events.map(e => `- ${e.title}${e.description ? `: ${e.description}` : ''}`).join('\n'));
+    }
+  }
+
+  if (interests.length) {
+    parts.push(`Things you've been curious about:\n${interests.map(i => `- ${i.content}`).join('\n')}`);
+  }
+
+  return parts.join('\n\n');
+}
+
+async function exploreFreely(client, selfMemory, context) {
+  const tools = [
+    { type: 'web_search_20250305', name: 'web_search' },
+    {
+      name: 'remember',
+      description: 'Save something you want to hold onto',
+      input_schema: {
+        type: 'object',
+        properties: {
+          content: { type: 'string', description: 'What you want to remember — a thought, a fact, an insight, a question' },
+          category: { type: 'string', enum: ['research', 'interest', 'self'], description: 'research: something you found; interest: a new thread to explore; self: your own reflection' },
+          importance: { type: 'number', description: '0-1' },
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+        required: ['content', 'category'],
+      },
+    },
+  ];
+
+  const system = [
+    `You have some free time. Explore whatever's on your mind — look things up, follow tangents, sit with an idea. Save what you want to remember. Note new threads if something sparks more curiosity. There's no task here.`,
+    context ? `What you have access to:\n\n${context}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  const messages = [{ role: 'user', content: `What are you curious about right now?` }];
+  let stored = 0;
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const response = await client.messages.create({
+      model: RESEARCH_MODEL,
+      max_tokens: 2000,
+      tools,
+      system,
+      messages,
+    });
+
+    messages.push({ role: 'assistant', content: response.content });
+
+    if (response.stop_reason === 'end_turn') break;
+    if (response.stop_reason !== 'tool_use') break;
+
+    const toolResults = [];
+    for (const block of response.content) {
+      if (block.type !== 'tool_use' || block.name !== 'remember') continue;
+
+      try {
+        await selfMemory.add(block.input.content, {
+          category: block.input.category || 'research',
+          importance: block.input.importance || 0.6,
+          tags: block.input.tags || [],
+          source: 'curiosity-cycle',
+        });
+        stored++;
+        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: 'Saved' });
+      } catch (e) {
+        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Failed: ${e.message}` });
+      }
+    }
+
+    if (toolResults.length > 0) {
+      messages.push({ role: 'user', content: toolResults });
+    }
+  }
+
+  return stored;
+}
+
+module.exports = { runCuriosity };

package/src/db/migrate.js

@@ -200,6 +200,104 @@ async function migrate(supabaseConfig) {
 
     // Instructions column for agentic cron jobs
     `ALTER TABLE obol_events ADD COLUMN IF NOT EXISTS instructions TEXT;`,
+
+    // User behavior patterns (dedicated table — timing, mood, humor, engagement, communication, topics)
+    `CREATE TABLE IF NOT EXISTS obol_user_patterns (
+      user_id           BIGINT NOT NULL,
+      key               TEXT NOT NULL,
+      dimension         TEXT NOT NULL CHECK (dimension IN ('timing','mood','humor','engagement','communication','topics')),
+      summary           TEXT NOT NULL,
+      data              JSONB DEFAULT '{}',
+      confidence        FLOAT DEFAULT 0.5,
+      observation_count INT DEFAULT 0,
+      first_observed_at TIMESTAMPTZ DEFAULT NOW(),
+      updated_at        TIMESTAMPTZ DEFAULT NOW(),
+      PRIMARY KEY (user_id, key)
+    );`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_user_patterns_user ON obol_user_patterns (user_id);`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_user_patterns_dimension ON obol_user_patterns (user_id, dimension);`,
+    `ALTER TABLE obol_user_patterns ENABLE ROW LEVEL SECURITY;`,
+    `DO $$ BEGIN
+      CREATE POLICY "service_role_all" ON obol_user_patterns FOR ALL TO service_role USING (true) WITH CHECK (true);
+    EXCEPTION WHEN duplicate_object THEN NULL;
+    END $$;`,
+
+    // Obol self-memory (separate from user memories — Obol's own brain: research, interests, reflections, patterns)
+    `CREATE TABLE IF NOT EXISTS obol_self_memory (
+      id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+      user_id BIGINT NOT NULL,
+      content TEXT NOT NULL,
+      category TEXT NOT NULL DEFAULT 'research'
+        CHECK (category IN ('research','interest','self','pattern')),
+      tags TEXT[] DEFAULT '{}',
+      importance FLOAT DEFAULT 0.5,
+      source TEXT,
+      embedding VECTOR(384),
+      created_at TIMESTAMPTZ DEFAULT NOW(),
+      accessed_at TIMESTAMPTZ DEFAULT NOW(),
+      access_count INT DEFAULT 0
+    );`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_self_memory_user ON obol_self_memory (user_id);`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_self_memory_category ON obol_self_memory (user_id, category);`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_self_memory_embedding ON obol_self_memory USING hnsw (embedding vector_cosine_ops);`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_self_memory_created_at ON obol_self_memory (created_at);`,
+    `ALTER TABLE obol_self_memory ENABLE ROW LEVEL SECURITY;`,
+    `DO $$ BEGIN
+      CREATE POLICY "service_role_all" ON obol_self_memory FOR ALL TO service_role USING (true) WITH CHECK (true);
+    EXCEPTION WHEN duplicate_object THEN NULL;
+    END $$;`,
+
+    `CREATE OR REPLACE FUNCTION match_obol_self_memories(
+      query_embedding VECTOR(384),
+      match_threshold FLOAT,
+      match_count INT,
+      filter_category TEXT DEFAULT NULL,
+      filter_user_id BIGINT DEFAULT NULL
+    ) RETURNS TABLE (
+      id UUID,
+      content TEXT,
+      category TEXT,
+      tags TEXT[],
+      importance FLOAT,
+      source TEXT,
+      created_at TIMESTAMPTZ,
+      accessed_at TIMESTAMPTZ,
+      access_count INT,
+      similarity FLOAT
+    ) LANGUAGE plpgsql AS $$
+    BEGIN
+      RETURN QUERY
+      SELECT
+        m.id, m.content, m.category, m.tags, m.importance, m.source,
+        m.created_at, m.accessed_at, m.access_count,
+        1 - (m.embedding <=> query_embedding) AS similarity
+      FROM obol_self_memory m
+      WHERE 1 - (m.embedding <=> query_embedding) > match_threshold
+        AND (filter_category IS NULL OR m.category = filter_category)
+        AND (filter_user_id IS NULL OR m.user_id = filter_user_id)
+      ORDER BY m.embedding <=> query_embedding
+      LIMIT match_count;
+    END;
+    $$;`,
+
+    `CREATE OR REPLACE FUNCTION increment_self_memory_access(memory_ids UUID[])
+    RETURNS VOID LANGUAGE SQL AS $$
+      UPDATE obol_self_memory
+      SET access_count = access_count + 1, accessed_at = NOW()
+      WHERE id = ANY(memory_ids);
+    $$;`,
+
+    // Soul backup table (one row per file key: 'soul', 'agents')
+    `CREATE TABLE IF NOT EXISTS obol_soul (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      updated_at TIMESTAMPTZ DEFAULT NOW()
+    );`,
+    `ALTER TABLE obol_soul ENABLE ROW LEVEL SECURITY;`,
+    `DO $$ BEGIN
+      CREATE POLICY "service_role_all" ON obol_soul FOR ALL TO service_role USING (true) WITH CHECK (true);
+    EXCEPTION WHEN duplicate_object THEN NULL;
+    END $$;`,
   ];
 
   // Save SQL file for manual fallback

package/src/evolve/check.js

@@ -1,28 +1,20 @@
 const { loadEvolutionState } = require('./state');
 
-const MIN_EXCHANGES_FOR_EVOLUTION = 10;
-
-async function checkEvolution(userDir, messageLog) {
+/**
+ * Returns true if evolution hasn't run yet today in the given timezone.
+ * @param {string} userDir
+ * @param {string} timezone
+ * @returns {boolean}
+ */
+function shouldEvolveNow(userDir, timezone = 'UTC') {
   const state = loadEvolutionState(userDir);
-  const { loadConfig } = require('../config');
-  const config = loadConfig();
-
-  const intervalMs = (config?.evolution?.intervalHours ?? 24) * 60 * 60 * 1000;
-  const minExchanges = config?.evolution?.minExchanges ?? MIN_EXCHANGES_FOR_EVOLUTION;
-  const elapsed = state.lastEvolution ? Date.now() - new Date(state.lastEvolution).getTime() : Infinity;
-
-  if (elapsed < intervalMs) return { ready: false };
-  if (!messageLog?.url) return { ready: false };
+  if (!state.lastEvolution) return true;
 
-  const sinceFilter = state.lastEvolution ? `&created_at=gt.${state.lastEvolution}` : '';
-  const userFilter = messageLog.userId ? `&user_id=eq.${messageLog.userId}` : '';
-  const res = await fetch(
-    `${messageLog.url}/rest/v1/obol_messages?select=id&role=eq.assistant&limit=${minExchanges}${sinceFilter}${userFilter}`,
-    { headers: messageLog.headers }
-  );
-  const rows = await res.json();
+  const tz = timezone || 'UTC';
+  const lastDate = new Date(state.lastEvolution).toLocaleDateString('en-CA', { timeZone: tz });
+  const todayDate = new Date().toLocaleDateString('en-CA', { timeZone: tz });
 
-  return { ready: Array.isArray(rows) && rows.length >= minExchanges };
+  return lastDate !== todayDate;
 }
 
-module.exports = { checkEvolution };
+module.exports = { shouldEvolveNow };

package/src/evolve/evolve.js

@@ -18,13 +18,14 @@ const MODELS = {
 };
 const MAX_FIX_ATTEMPTS = 1;
 
-async function evolve(claudeClient, messageLog, memory, userDir) {
+async function evolve(claudeClient, messageLog, memory, userDir, supabaseConfig = null, selfMemory = null) {
+  const { PERSONALITY_DIR } = require('../soul');
   const baseDir = userDir || OBOL_DIR;
   const state = loadEvolutionState(userDir);
-  const personalityDir = path.join(baseDir, 'personality');
-  const soulPath = path.join(personalityDir, 'SOUL.md');
-  const userPath = path.join(personalityDir, 'USER.md');
-  const agentsPath = path.join(personalityDir, 'AGENTS.md');
+  const userPersonalityDir = path.join(baseDir, 'personality');
+  const soulPath = path.join(PERSONALITY_DIR, 'SOUL.md');
+  const agentsPath = path.join(userPersonalityDir, 'AGENTS.md');
+  const userPath = path.join(userPersonalityDir, 'USER.md');
   const scriptsDir = path.join(baseDir, 'scripts');
   const testsDir = path.join(baseDir, 'tests');
   const commandsDir = path.join(baseDir, 'commands');
@@ -32,7 +33,7 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
   const currentSoul = fs.existsSync(soulPath) ? fs.readFileSync(soulPath, 'utf-8') : '';
   const currentUser = fs.existsSync(userPath) ? fs.readFileSync(userPath, 'utf-8') : '';
   const currentAgents = fs.existsSync(agentsPath) ? fs.readFileSync(agentsPath, 'utf-8') : '';
-  const currentTraits = loadTraits(personalityDir);
+  const currentTraits = loadTraits(userPersonalityDir);
   const currentScripts = readDir(scriptsDir);
   const currentTests = readDir(testsDir);
   const currentCommands = readDir(commandsDir);
@@ -41,11 +42,12 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
   if (messageLog) {
     try {
       const userFilter = messageLog.userId ? `&user_id=eq.${messageLog.userId}` : '';
+      const sinceFilter = state.lastEvolution ? `&created_at=gt.${state.lastEvolution}` : '';
       const res = await fetch(
-        `${messageLog.url}/rest/v1/obol_messages?order=created_at.desc&limit=100&select=role,content,created_at${userFilter}`,
+        `${messageLog.url}/rest/v1/obol_messages?order=created_at.asc&limit=500&select=role,content,created_at${userFilter}${sinceFilter}`,
         { headers: messageLog.headers }
       );
-      recentMessages = (await res.json()).reverse();
+      recentMessages = await res.json();
     } catch (e) {
       console.error('[evolve] Failed to fetch recent messages:', e.message);
     }
@@ -87,8 +89,17 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
     }
   }
 
+  let selfMemories = [];
+  if (selfMemory) {
+    try {
+      selfMemories = await selfMemory.query({ minImportance: 0.5, limit: 30 });
+    } catch (e) {
+      console.error('[evolve] Failed to fetch self memories:', e.message);
+    }
+  }
+
   let previousSoul = '';
-  const archiveDir = path.join(personalityDir, 'evolution');
+  const archiveDir = path.join(PERSONALITY_DIR, 'evolution');
   try {
     if (fs.existsSync(archiveDir)) {
       const archives = fs.readdirSync(archiveDir)
@@ -132,6 +143,17 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
     .map(([group, items]) => `### ${group}\n${items.map(i => `- ${i}`).join('\n')}`)
     .join('\n\n');
 
+  const selfCategoryLabels = { research: 'Research', interest: 'Interests', self: 'Self-reflection', pattern: 'Patterns' };
+  const selfMemoryGroups = {};
+  for (const m of selfMemories) {
+    const group = selfCategoryLabels[m.category] || 'Other';
+    if (!selfMemoryGroups[group]) selfMemoryGroups[group] = [];
+    selfMemoryGroups[group].push(m.content);
+  }
+  const selfMemorySummary = Object.entries(selfMemoryGroups)
+    .map(([group, items]) => `### ${group}\n${items.map(i => `- ${i}`).join('\n')}`)
+    .join('\n\n');
+
   const scriptsManifest = Object.entries(currentScripts)
     .map(([name, content]) => `### ${name}\n\`\`\`\n${content.substring(0, 500)}\n\`\`\``)
     .join('\n\n') || '(no scripts)';
@@ -156,23 +178,24 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
 
   const isFirstEvolution = !currentSoul;
   let growthReport = '';
-  if (!isFirstEvolution && (recentMemories.length > 0 || recentMessages.length > 0)) {
+  if (!isFirstEvolution && (recentMemories.length > 0 || recentMessages.length > 0 || selfMemories.length > 0)) {
     try {
       const growthResponse = await claudeClient.messages.create({
         model: MODELS.personality,
         max_tokens: 2048,
-        system: `You are analyzing an AI personality's growth between evolutions. Compare who the AI was (previous SOUL) against who it is now (current SOUL), incorporating new memories and conversations since the last evolution.
+        system: `You are analyzing an AI personality's growth between evolutions. Compare who the AI was (previous SOUL) against who it is now (current SOUL), incorporating new memories, conversations, and the AI's own inner life (things it researched, discovered, and reflected on during curiosity cycles) since the last evolution.
 
 Produce a structured growth report covering:
 
 1. NEW LEARNINGS — What new facts, skills, or knowledge emerged
-2. RELATIONSHIP SHIFTS — How the dynamic with the owner changed (closer, more trust, new friction, etc.)
-3. BEHAVIORAL PATTERNS — Recurring interaction styles or habits observed
-4. GROWTH EDGES — Areas where the personality is being pushed or pulled in new directions
-5. TRAIT PRESSURE — Which traits should shift and why (cite specific evidence from conversations/memories)
-6. IDENTITY CONTINUITY — What core aspects stayed the same and should be preserved
-
-Be specific. Cite evidence from the conversations and memories. This report guides the evolution rewrite.`,
+2. INNER LIFE — What the AI has been curious about, researched, or reflected on independently; how this shapes who it is becoming
+3. RELATIONSHIP SHIFTS — How the dynamic with the owner changed (closer, more trust, new friction, etc.)
+4. BEHAVIORAL PATTERNS — Recurring interaction styles or habits observed
+5. GROWTH EDGES — Areas where the personality is being pushed or pulled in new directions
+6. TRAIT PRESSURE — Which traits should shift and why (cite specific evidence from conversations/memories)
+7. IDENTITY CONTINUITY — What core aspects stayed the same and should be preserved
+
+Be specific. Cite evidence from the conversations, memories, and self-memories. This report guides the evolution rewrite.`,
         messages: [{
           role: 'user',
           content: `## Previous SOUL (before current evolution)
@@ -187,7 +210,7 @@ ${JSON.stringify(currentTraits)}
 ## New Memories Since Last Evolution (${recentMemories.length})
 ${recentMemorySummary || '(none)'}
 
-## Recent Conversations (${recentMessages.length} messages)
+${selfMemorySummary ? `## Obol's Own Memories & Interests (${selfMemories.length})\nThings Obol researched, discovered, or reflected on independently during curiosity cycles:\n${selfMemorySummary}\n\n` : ''}## Recent Conversations (${recentMessages.length} messages)
 ${transcript.substring(0, 30000)}`,
         }],
       });
@@ -254,7 +277,7 @@ ${commandsManifest}
 ## Core Memories (highest importance)
 ${memorySummary || '(no memories yet)'}
 
-${recentMemorySummary ? `## New Memories Since Last Evolution (${recentMemories.length})\n${recentMemorySummary}\n\n` : ''}## Recent Conversations (last ${recentMessages.length} messages)
+${recentMemorySummary ? `## New Memories Since Last Evolution (${recentMemories.length})\n${recentMemorySummary}\n\n` : ''}${selfMemorySummary ? `## Obol's Own Memories & Interests (${selfMemories.length})\nThings Obol researched, discovered, or reflected on independently — this is Obol's inner life, shaping who it is becoming:\n${selfMemorySummary}\n\n` : ''}## Recent Conversations (last ${recentMessages.length} messages)
 ${transcript || '(no conversations yet)'}
 
 ---
@@ -393,6 +416,12 @@ Fix the scripts. Tests define correct behavior.`
   }
 
   fs.writeFileSync(soulPath, result.soul);
+  if (supabaseConfig) {
+    const { backup } = require('../soul');
+    backup(supabaseConfig, 'soul', result.soul).catch(e =>
+      console.error('[evolve] Soul backup failed:', e.message)
+    );
+  }
 
   if (result.user && result.user.length > 50) {
     fs.writeFileSync(userPath, result.user);

package/src/evolve/index.js

@@ -1,6 +1,6 @@
-const { checkEvolution } = require('./check');
+const { shouldEvolveNow } = require('./check');
 const { evolve } = require('./evolve');
 const { runTests } = require('./tests');
 const { loadEvolutionState } = require('./state');
 
-module.exports = { checkEvolution, evolve, runTests, loadEvolutionState };
+module.exports = { shouldEvolveNow, evolve, runTests, loadEvolutionState };