obol-ai 0.2.39 → 0.3.1

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 };

package/src/heartbeat.js

@@ -1,6 +1,151 @@
 const cron = require('node-cron');
 const { createScheduler } = require('./scheduler');
 const { getTenant } = require('./tenant');
+const { shouldEvolveNow, evolve } = require('./evolve');
+const { ensureUserDir } = require('./config');
+const { runAnalysis } = require('./analysis');
+const { runCuriosity } = require('./curiosity');
+const { runCuriosityDispatch } = require('./curiosity-dispatch');
+const { runCuriosityHumor } = require('./curiosity-humor');
+const { createSelfMemory } = require('./memory-self');
+
+
+const ANALYSIS_HOURS = new Set([4, 7, 10, 13, 16, 19, 22]);
+const CURIOSITY_HOURS = new Set([1, 7, 13, 19]);
+
+const _evolutionRunning = new Set();
+let _curiosityRunning = false;
+
+function getLocalHour(timezone) {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  }).formatToParts(new Date());
+  return {
+    hour: parseInt(parts.find(p => p.type === 'hour').value),
+    minute: parseInt(parts.find(p => p.type === 'minute').value),
+  };
+}
+
+async function runEvolutionForUser(bot, config, userId) {
+  if (_evolutionRunning.has(userId)) return;
+
+  const timezone = config.timezone || 'UTC';
+  const userDir = ensureUserDir(userId);
+
+  if (!shouldEvolveNow(userDir, timezone)) return;
+
+  _evolutionRunning.add(userId);
+  console.log(`[evolution] Starting nightly evolution for user ${userId}`);
+
+  try {
+    const tenant = await getTenant(userId, config);
+    const selfMemory = config.supabase ? await createSelfMemory(config.supabase, 0).catch(() => null) : null;
+    const result = await evolve(tenant.claude.client, tenant.messageLog, tenant.memory, tenant.userDir, config.supabase, selfMemory);
+    tenant.claude.reloadPersonality?.();
+
+    let msg = `🪙 Evolution #${result.evolutionNumber} complete.`;
+    if (result.scriptsFixed) msg += '\n🔧 Fixed a test regression automatically.';
+    else if (result.scriptsRolledBack) msg += '\n⚠️ Rolled back a script refactor — tests couldn\'t be fixed.';
+
+    if (result.upgrades?.length > 0) {
+      msg += '\n\n🆕 <b>New capabilities:</b>';
+      for (const u of result.upgrades) {
+        msg += `\n• <b>${u.name}</b> — ${u.description}`;
+        if (u.command) msg += ` → <code>${u.command}</code>`;
+      }
+    }
+
+    if (result.deployedApps?.length > 0) {
+      msg += '\n\n🚀 <b>Deployed:</b>';
+      for (const app of result.deployedApps) {
+        msg += app.url
+          ? `\n• ${app.name} → ${app.url}`
+          : `\n• ${app.name} — deploy failed: ${(app.error || '').substring(0, 100)}`;
+      }
+    }
+
+    if (result.changelog) msg += `\n\n<i>${result.changelog}</i>`;
+
+    await bot.api.sendMessage(userId, msg, { parse_mode: 'HTML' }).catch(() => {});
+    console.log(`[evolution] Completed evolution #${result.evolutionNumber} for user ${userId}`);
+  } catch (e) {
+    console.error(`[evolution] Failed for user ${userId}:`, e.message);
+  } finally {
+    _evolutionRunning.delete(userId);
+  }
+}
+
+async function runCuriosityOnce(config, allowedUsers) {
+  if (!config.supabase) return;
+  if (_curiosityRunning) {
+    console.log('[curiosity] Skipping — previous cycle still running');
+    return;
+  }
+  _curiosityRunning = true;
+  try {
+    const selfMemory = await createSelfMemory(config.supabase, 0);
+    const firstTenant = await getTenant(allowedUsers[0], config);
+    const client = firstTenant.claude.client;
+
+    const contexts = await Promise.all(allowedUsers.map(async (userId) => {
+      try {
+        const tenant = await getTenant(userId, config);
+        const parts = [];
+        if (tenant.personality?.user) parts.push(tenant.personality.user);
+        if (tenant.patterns) {
+          const fmt = await tenant.patterns.format().catch(() => null);
+          if (fmt) parts.push(fmt);
+        }
+        if (tenant.memory) {
+          const recent = await tenant.memory.recent({ limit: 3 }).catch(() => []);
+          if (recent.length) parts.push(recent.map(m => `- ${m.content}`).join('\n'));
+        }
+        if (tenant.scheduler) {
+          const events = await tenant.scheduler.list({ status: 'pending', limit: 3 }).catch(() => []);
+          if (events.length) parts.push(events.map(e => `- ${e.title}`).join('\n'));
+        }
+        return parts.join('\n');
+      } catch {
+        return null;
+      }
+    }));
+
+    const peopleContext = contexts.filter(Boolean).join('\n\n---\n\n');
+    await runCuriosity(client, selfMemory, 0, { peopleContext });
+
+    const userDispatchData = await Promise.all(allowedUsers.map(async (userId) => {
+      try {
+        const tenant = await getTenant(userId, config);
+        const patterns = tenant.patterns ? await tenant.patterns.format().catch(() => null) : null;
+        const events = tenant.scheduler
+          ? await tenant.scheduler.list({ status: 'pending', limit: 5 }).catch(() => [])
+          : [];
+        const userProfile = tenant.personality?.user || null;
+        return { userId, chatId: userId, timezone: config.timezone || 'UTC', patterns, events, scheduler: tenant.scheduler, userProfile };
+      } catch { return null; }
+    }));
+    await runCuriosityDispatch(client, selfMemory, userDispatchData.filter(Boolean));
+    await runCuriosityHumor(client, selfMemory, userDispatchData.filter(Boolean));
+  } catch (e) {
+    console.error('[curiosity] Failed:', e.message);
+  } finally {
+    _curiosityRunning = false;
+  }
+}
+
+async function runAnalysisForUser(bot, config, userId) {
+  const timezone = config.timezone || 'UTC';
+  try {
+    const tenant = await getTenant(userId, config);
+    if (!tenant.messageLog || !tenant.scheduler || !tenant.patterns) return;
+    await runAnalysis(tenant.claude.client, tenant.messageLog, tenant.scheduler, tenant.patterns, tenant.memory, userId, userId, timezone);
+  } catch (e) {
+    console.error(`[analysis] Failed for user ${userId}:`, e.message);
+  }
+}
 
 function makeFakeCtx(bot, chatId) {
   return {
@@ -52,6 +197,46 @@ function setupHeartbeat(bot, config) {
     }
   });
 
+  const allowedUsers = config?.telegram?.allowedUsers || [];
+  if (allowedUsers.length > 0) {
+    cron.schedule('* * * * *', async () => {
+      const timezone = config.timezone || 'UTC';
+      const { hour, minute } = getLocalHour(timezone);
+      if (hour !== 3 || minute !== 0) return;
+
+      for (const userId of allowedUsers) {
+        runEvolutionForUser(bot, config, userId).catch(e =>
+          console.error(`[evolution] Unhandled error for user ${userId}:`, e.message)
+        );
+      }
+    });
+    console.log(`  ✅ Evolution cron running (daily 3am ${config.timezone || 'UTC'})`);
+
+    cron.schedule('* * * * *', async () => {
+      const timezone = config.timezone || 'UTC';
+      const { hour, minute } = getLocalHour(timezone);
+      if (!ANALYSIS_HOURS.has(hour) || minute !== 0) return;
+
+      for (const userId of allowedUsers) {
+        runAnalysisForUser(bot, config, userId).catch(e =>
+          console.error(`[analysis] Unhandled error for user ${userId}:`, e.message)
+        );
+      }
+    });
+    console.log(`  ✅ Analysis cron running (every 3h ${config.timezone || 'UTC'})`);
+
+    cron.schedule('* * * * *', async () => {
+      const timezone = config.timezone || 'UTC';
+      const { hour, minute } = getLocalHour(timezone);
+      if (!CURIOSITY_HOURS.has(hour) || minute !== 0) return;
+
+      runCuriosityOnce(config, allowedUsers).catch(e =>
+        console.error('[curiosity] Unhandled error:', e.message)
+      );
+    });
+    console.log(`  ✅ Curiosity cron running (every 6h ${config.timezone || 'UTC'})`);
+  }
+
   console.log('  ✅ Heartbeat running (every 1min)');
 }
 
@@ -69,17 +254,54 @@ async function sendReminderMessage(bot, event) {
   );
 }
 
+async function buildProactiveContext(tenant, timezone, query) {
+  const parts = [];
+
+  const localTime = new Date().toLocaleString('en-US', {
+    timeZone: timezone,
+    weekday: 'long',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true,
+  });
+  parts.push(`Local time: ${localTime} (${timezone})`);
+
+  if (tenant.patterns) {
+    const formatted = await tenant.patterns.format().catch(() => null);
+    if (formatted) parts.push(`\nUser patterns:\n${formatted}`);
+  }
+
+  if (tenant.memory) {
+    const memories = query
+      ? await tenant.memory.search(query, { limit: 5 }).catch(() => [])
+      : await tenant.memory.recent({ limit: 5 }).catch(() => []);
+    if (memories.length > 0) {
+      parts.push(`\nRecent memory:\n${memories.map(m => `- ${m.content}`).join('\n')}`);
+    }
+  }
+
+  return parts.join('\n');
+}
+
 async function runAgenticEvent(bot, config, event) {
   const tenant = await getTenant(event.user_id, config);
+  const timezone = event.timezone || config.timezone || 'UTC';
+
+  const query = event.description || event.instructions;
+  const context = await buildProactiveContext(tenant, timezone, query).catch(() => '');
+  const instructions = context
+    ? `[Context]\n${context}\n\n---\n\n${event.instructions}`
+    : event.instructions;
+
   const fakeCtx = makeFakeCtx(bot, event.chat_id);
 
   const taskId = tenant.bg.spawn(
     tenant.claude,
-    event.instructions,
+    instructions,
     fakeCtx,
     tenant.memory,
     null,
-    {},
+    { silent: true },
     {
       userId: event.user_id,
       chatId: event.chat_id,

package/src/index.js

@@ -1,9 +1,12 @@
+const fs = require('fs');
+const path = require('path');
 const { loadConfig } = require('./config');
 const { createBot, checkUpgradeNotify } = require('./telegram');
 const { setupBackup } = require('./backup');
 const { setupHeartbeat } = require('./heartbeat');
 const { migrateToMultiTenant } = require('./legacy-migrate');
 const { isPostSetupDone, runPostSetup } = require('./post-setup');
+const { restoreIfMissing, PERSONALITY_DIR } = require('./soul');
 
 async function main() {
   const config = loadConfig();
@@ -24,8 +27,16 @@ async function main() {
     } catch (e) {
       console.error(`  Database migration failed: ${e.message}`);
     }
+
+    try {
+      await restoreIfMissing(config.supabase);
+    } catch (e) {
+      console.error(`  Soul restore failed: ${e.message}`);
+    }
   }
 
+  fs.mkdirSync(PERSONALITY_DIR, { recursive: true });
+
   if (!isPostSetupDone()) {
     runPostSetup(loadConfig({ resolve: false }), console.log).catch(e =>
       console.error('Post-setup error:', e.message)

package/src/memory-self.js

@@ -0,0 +1,123 @@
+const { getEmbedding } = require('./memory');
+
+const VALID_CATEGORIES = new Set(['research', 'interest', 'self', 'pattern']);
+
+async function createSelfMemory(supabaseConfig, userId) {
+  const { url, serviceKey } = supabaseConfig;
+
+  const headers = {
+    'apikey': serviceKey,
+    'Authorization': `Bearer ${serviceKey}`,
+    'Content-Type': 'application/json',
+    'Prefer': 'return=representation',
+  };
+
+  async function add(content, opts = {}) {
+    const category = VALID_CATEGORIES.has(opts.category) ? opts.category : 'research';
+    const importance = opts.importance || 0.5;
+    const source = opts.source || null;
+    const tags = opts.tags || [];
+
+    const embedding = await getEmbedding(content);
+
+    const res = await fetch(`${url}/rest/v1/obol_self_memory`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ content, category, importance, source, tags, embedding, user_id: userId }),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data[0];
+  }
+
+  async function search(query, opts = {}) {
+    const embedding = await getEmbedding(query);
+    const limit = opts.limit || 10;
+    const threshold = opts.threshold || 0.3;
+    const category = opts.category || null;
+
+    const res = await fetch(`${url}/rest/v1/rpc/match_obol_self_memories`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        query_embedding: embedding,
+        match_threshold: threshold,
+        match_count: limit,
+        filter_category: category,
+        filter_user_id: userId,
+      }),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+
+    if (data.length > 0) {
+      const ids = data.map(m => m.id);
+      await fetch(`${url}/rest/v1/rpc/increment_self_memory_access`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ memory_ids: ids }),
+      }).catch(() => {});
+    }
+
+    return data;
+  }
+
+  async function recent(opts = {}) {
+    const limit = opts.limit || 10;
+    let fetchUrl = `${url}/rest/v1/obol_self_memory?select=id,content,category,tags,importance,source,created_at&order=created_at.desc&limit=${limit}&user_id=eq.${userId}`;
+    if (opts.category) fetchUrl += `&category=eq.${opts.category}`;
+
+    const res = await fetch(fetchUrl, { headers });
+    if (!res.ok) throw new Error(`Self memory recent failed: HTTP ${res.status}`);
+    return await res.json();
+  }
+
+  async function query(opts = {}) {
+    const limit = opts.limit || 20;
+    const parts = [`user_id=eq.${userId}`];
+    if (opts.category) parts.push(`category=eq.${opts.category}`);
+    if (opts.source) parts.push(`source=eq.${opts.source}`);
+    if (opts.minImportance) parts.push(`importance=gte.${opts.minImportance}`);
+    if (opts.tags?.length) parts.push(`tags=ov.{${opts.tags.join(',')}}`);
+
+    const res = await fetch(
+      `${url}/rest/v1/obol_self_memory?select=id,content,category,tags,importance,source,created_at&${parts.join('&')}&order=created_at.desc&limit=${limit}`,
+      { headers }
+    );
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data;
+  }
+
+  async function update(id, opts = {}) {
+    const patch = {};
+    if (opts.content !== undefined) {
+      patch.content = opts.content;
+      patch.embedding = await getEmbedding(opts.content);
+    }
+    if (opts.category !== undefined && VALID_CATEGORIES.has(opts.category)) patch.category = opts.category;
+    if (opts.importance !== undefined) patch.importance = opts.importance;
+    if (opts.tags !== undefined) patch.tags = opts.tags;
+    if (opts.source !== undefined) patch.source = opts.source;
+
+    const res = await fetch(`${url}/rest/v1/obol_self_memory?id=eq.${id}`, {
+      method: 'PATCH',
+      headers,
+      body: JSON.stringify(patch),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data[0];
+  }
+
+  async function forget(id) {
+    await fetch(`${url}/rest/v1/obol_self_memory?id=eq.${id}`, {
+      method: 'DELETE',
+      headers: { ...headers, 'Prefer': 'return=minimal' },
+    });
+  }
+
+  return { add, search, recent, query, update, forget };
+}
+
+module.exports = { createSelfMemory };