obol-ai 0.2.39 → 0.3.1

package/src/messages.js

@@ -3,6 +3,8 @@
  *
  * Tier 1: obol_messages — raw log, every message
  * Tier 2: obol_memory — curated facts, extracted after every assistant turn
+ * Tier 3: obol_events — follow-up intents, detected by batch analysis (see analysis.js)
+ * Tier 4: obol_user_patterns — synthesized behavioral patterns, refreshed by batch analysis (see analysis.js)
  */
 
 const Anthropic = require('@anthropic-ai/sdk');
@@ -24,6 +26,7 @@ class MessageLog {
     this.exchangeCount = new Map();
     this._lastUserMessage = new Map();
     this._verboseCallbacks = new Map();
+    this._lastActivity = new Map();
     this._cleanup = setInterval(() => {
       const now = Date.now();
       for (const [key] of this.exchangeCount) {
@@ -35,7 +38,6 @@ class MessageLog {
       }
     }, 600000);
     this._cleanup.unref();
-    this._lastActivity = new Map();
   }
 
   async log(chatId, role, content, opts = {}) {
@@ -71,17 +73,9 @@ class MessageLog {
       if (lastUser) {
         this._extractFacts(chatId, lastUser, truncated).catch(() => {});
       }
-
-      const { checkEvolution } = require('./evolve');
-      checkEvolution(this.userDir, this).then(result => {
-        if (result?.ready && !this._evolutionReady && !this._evolutionPending) this._evolutionReady = true;
-      }).catch(() => {});
     }
   }
 
-  /**
-   * Get recent messages for context loading on boot
-   */
   async getRecent(chatId, limit = 50) {
     try {
       const res = await fetch(
@@ -89,7 +83,7 @@ class MessageLog {
         { headers: this.headers }
       );
       const data = await res.json();
-      const rows = data.reverse(); // oldest first
+      const rows = data.reverse();
       const firstUserIdx = rows.findIndex(r => r.role === 'user');
       return firstUserIdx > 0 ? rows.slice(firstUserIdx) : rows;
     } catch {
@@ -97,9 +91,20 @@ class MessageLog {
     }
   }
 
-  /**
-   * Get messages by date range for history retrieval
-   */
+  async getSince(chatId, since, limit = 500) {
+    try {
+      const res = await fetch(
+        `${this.url}/rest/v1/obol_messages?chat_id=eq.${chatId}&created_at=gte.${since.toISOString()}&order=created_at.asc&limit=${limit}&select=role,content,created_at`,
+        { headers: this.headers }
+      );
+      const data = await res.json();
+      if (!res.ok) return [];
+      return data;
+    } catch {
+      return [];
+    }
+  }
+
   async getByDate(chatId, dateStr, opts = {}) {
     const { start, end } = parseDateRange(dateStr);
     const limit = opts.limit || 50;
@@ -165,13 +170,12 @@ class MessageLog {
       const response = await client.messages.create({
         model: 'claude-haiku-4-5-20251001',
         max_tokens: 1024,
-        system: `Extract 0-5 atomic facts from this exchange worth remembering long-term.
+        system: `Extract facts from this exchange.
 
+FACTS (0-5 atomic facts worth remembering long-term):
 Store: personal details, preferences, decisions, projects, plans, people mentioned, technical details, events, deadlines, emotional context, resources.
-Skip: greetings, acknowledgments, content-free exchanges. Use facts=[] if nothing worth storing.
-
-Importance: 0.3 minor, 0.5 useful, 0.7 important, 0.9 critical.
-Keep each fact atomic — one idea per entry.`,
+Skip: greetings, acknowledgments, content-free exchanges.
+Importance: 0.3 minor, 0.5 useful, 0.7 important, 0.9 critical.`,
         tools: extractTool,
         tool_choice: { type: 'tool', name: 'save_memory' },
         messages: [{ role: 'user', content: `Human: ${userMsg.substring(0, 2000)}\nAssistant: ${assistantMsg.substring(0, 2000)}` }],
@@ -181,38 +185,31 @@ Keep each fact atomic — one idea per entry.`,
       if (!toolUse) return;
 
       const facts = toolUse.input?.facts;
-      if (!Array.isArray(facts)) return;
-
-      if (facts.length === 0) {
-        vlog?.('[extract] 0 facts (trivial exchange)');
-        return;
-      }
 
-      const validCategories = new Set(['fact','preference','decision','lesson','person','project','event','conversation','resource','pattern','context','email']);
-      let stored = 0;
-      let duped = 0;
-
-      for (const fact of facts.slice(0, 5)) {
-        if (!fact.content || fact.content.length <= 10) continue;
-        try {
-          const existing = await this.memory.search(fact.content, { limit: 1, threshold: 0.92 });
-          if (existing.length > 0) { duped++; continue; }
-        } catch {}
-        const category = validCategories.has(fact.category) ? fact.category : 'fact';
-        const importance = typeof fact.importance === 'number' ? Math.min(1, Math.max(0, fact.importance)) : 0.5;
-        const tags = Array.isArray(fact.tags) ? fact.tags.slice(0, 5) : [];
-        await this.memory.add(fact.content, {
-          category,
-          tags,
-          importance,
-          source: 'turn-extraction',
-        });
-        stored++;
-        vlog?.(`[extract] +[${category}] ${fact.content}`);
-      }
+      if (Array.isArray(facts) && facts.length > 0) {
+        const validCategories = new Set(['fact','preference','decision','lesson','person','project','event','conversation','resource','pattern','context','email']);
+        let stored = 0;
+        let duped = 0;
+
+        for (const fact of facts.slice(0, 5)) {
+          if (!fact.content || fact.content.length <= 10) continue;
+          try {
+            const existing = await this.memory.search(fact.content, { limit: 1, threshold: 0.92 });
+            if (existing.length > 0) { duped++; continue; }
+          } catch {}
+          const category = validCategories.has(fact.category) ? fact.category : 'fact';
+          const importance = typeof fact.importance === 'number' ? Math.min(1, Math.max(0, fact.importance)) : 0.5;
+          const tags = Array.isArray(fact.tags) ? fact.tags.slice(0, 5) : [];
+          await this.memory.add(fact.content, { category, tags, importance, source: 'turn-extraction' });
+          stored++;
+          vlog?.(`[extract] +[${category}] ${fact.content}`);
+        }
 
-      if (stored > 0 || duped > 0) {
-        vlog?.(`[extract] ${stored} stored, ${duped} duped, ${facts.length} extracted`);
+        if (stored > 0 || duped > 0) {
+          vlog?.(`[extract] ${stored} stored, ${duped} duped, ${facts.length} extracted`);
+        }
+      } else {
+        vlog?.('[extract] 0 facts (trivial exchange)');
       }
     } catch (e) {
       console.error('[extract] Failed:', e.message);

package/src/patterns.js

@@ -0,0 +1,111 @@
+const VALID_DIMENSIONS = new Set(['timing', 'mood', 'humor', 'engagement', 'communication', 'topics']);
+
+async function createPatterns(supabaseConfig, userId) {
+  const { url, serviceKey } = supabaseConfig;
+
+  const headers = {
+    'apikey': serviceKey,
+    'Authorization': `Bearer ${serviceKey}`,
+    'Content-Type': 'application/json',
+    'Prefer': 'return=representation',
+  };
+
+  async function upsert(key, dimension, summary, data = {}, confidence = 0.5) {
+    if (!VALID_DIMENSIONS.has(dimension)) throw new Error(`Invalid dimension: ${dimension}`);
+
+    const res = await fetch(`${url}/rest/v1/obol_user_patterns`, {
+      method: 'POST',
+      headers: { ...headers, 'Prefer': 'resolution=merge-duplicates,return=representation' },
+      body: JSON.stringify({
+        user_id: userId,
+        key,
+        dimension,
+        summary,
+        data,
+        confidence,
+        updated_at: new Date().toISOString(),
+        observation_count: 1,
+      }),
+    });
+    const result = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(result));
+    return result[0];
+  }
+
+  async function incrementObservation(key, dimension, summary, data = {}, confidence = 0.5) {
+    const existing = await get(key);
+    const count = (existing?.observation_count || 0) + 1;
+
+    const res = await fetch(`${url}/rest/v1/obol_user_patterns`, {
+      method: 'POST',
+      headers: { ...headers, 'Prefer': 'resolution=merge-duplicates,return=representation' },
+      body: JSON.stringify({
+        user_id: userId,
+        key,
+        dimension,
+        summary,
+        data,
+        confidence,
+        observation_count: count,
+        updated_at: new Date().toISOString(),
+      }),
+    });
+    const result = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(result));
+    return result[0];
+  }
+
+  async function get(key) {
+    const res = await fetch(
+      `${url}/rest/v1/obol_user_patterns?user_id=eq.${userId}&key=eq.${encodeURIComponent(key)}&limit=1`,
+      { headers }
+    );
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data[0] || null;
+  }
+
+  async function getAll() {
+    const res = await fetch(
+      `${url}/rest/v1/obol_user_patterns?user_id=eq.${userId}&order=dimension.asc,updated_at.desc`,
+      { headers }
+    );
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data;
+  }
+
+  async function getByDimension(dimension) {
+    const res = await fetch(
+      `${url}/rest/v1/obol_user_patterns?user_id=eq.${userId}&dimension=eq.${dimension}&order=updated_at.desc`,
+      { headers }
+    );
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data;
+  }
+
+  async function remove(key) {
+    await fetch(
+      `${url}/rest/v1/obol_user_patterns?user_id=eq.${userId}&key=eq.${encodeURIComponent(key)}`,
+      { method: 'DELETE', headers: { ...headers, 'Prefer': 'return=minimal' } }
+    );
+  }
+
+  async function format() {
+    const all = await getAll();
+    if (!all.length) return null;
+    const byDimension = {};
+    for (const p of all) {
+      if (!byDimension[p.dimension]) byDimension[p.dimension] = [];
+      byDimension[p.dimension].push(p.summary);
+    }
+    return Object.entries(byDimension)
+      .map(([dim, summaries]) => `[${dim}]\n${summaries.map(s => `- ${s}`).join('\n')}`)
+      .join('\n\n');
+  }
+
+  return { upsert, incrementObservation, get, getAll, getByDimension, remove, format };
+}
+
+module.exports = { createPatterns };

package/src/personality.js

@@ -4,17 +4,16 @@ const { OBOL_DIR } = require('./config');
 
 const DEFAULT_TRAITS = require('./defaults/traits.json');
 
-function loadPersonality(dir) {
-  dir = dir || path.join(OBOL_DIR, 'personality');
+function loadPersonality(sharedDir, userDir) {
+  sharedDir = sharedDir || path.join(OBOL_DIR, 'personality');
+  userDir = userDir || sharedDir;
   const personality = {};
 
-  const files = {
-    soul: 'SOUL.md',
-    user: 'USER.md',
-    agents: 'AGENTS.md',
-  };
-
-  for (const [key, filename] of Object.entries(files)) {
+  for (const [key, filename, dir] of [
+    ['soul', 'SOUL.md', sharedDir],
+    ['agents', 'AGENTS.md', userDir],
+    ['user', 'USER.md', userDir],
+  ]) {
     const filepath = path.join(dir, filename);
     try {
       personality[key] = fs.readFileSync(filepath, 'utf-8');
@@ -23,7 +22,7 @@ function loadPersonality(dir) {
     }
   }
 
-  personality.traits = loadTraits(dir);
+  personality.traits = loadTraits(userDir);
 
   return personality;
 }

package/src/soul.js

@@ -0,0 +1,53 @@
+const fs = require('fs');
+const path = require('path');
+const { OBOL_DIR } = require('./config');
+
+const PERSONALITY_DIR = path.join(OBOL_DIR, 'personality');
+
+function makeHeaders(supabaseConfig) {
+  return {
+    'apikey': supabaseConfig.serviceKey,
+    'Authorization': `Bearer ${supabaseConfig.serviceKey}`,
+    'Content-Type': 'application/json',
+    'Prefer': 'return=minimal',
+  };
+}
+
+async function backup(supabaseConfig, key, content) {
+  if (!supabaseConfig?.url || !supabaseConfig?.serviceKey) return;
+  await fetch(`${supabaseConfig.url}/rest/v1/obol_soul`, {
+    method: 'POST',
+    headers: { ...makeHeaders(supabaseConfig), 'Prefer': 'resolution=merge-duplicates,return=minimal' },
+    body: JSON.stringify({ id: key, content, updated_at: new Date().toISOString() }),
+  });
+}
+
+async function restore(supabaseConfig, key) {
+  if (!supabaseConfig?.url || !supabaseConfig?.serviceKey) return null;
+  const res = await fetch(`${supabaseConfig.url}/rest/v1/obol_soul?id=eq.${key}&select=content`, {
+    headers: makeHeaders(supabaseConfig),
+  });
+  if (!res.ok) return null;
+  const rows = await res.json();
+  return rows?.[0]?.content || null;
+}
+
+async function restoreIfMissing(supabaseConfig) {
+  if (!supabaseConfig?.url || !supabaseConfig?.serviceKey) return;
+  fs.mkdirSync(PERSONALITY_DIR, { recursive: true });
+
+  const soulPath = path.join(PERSONALITY_DIR, 'SOUL.md');
+  if (!fs.existsSync(soulPath)) {
+    try {
+      const content = await restore(supabaseConfig, 'soul');
+      if (content) {
+        fs.writeFileSync(soulPath, content);
+        console.log('  [soul] Restored SOUL.md from Supabase');
+      }
+    } catch (e) {
+      console.error(`  [soul] Failed to restore SOUL.md: ${e.message}`);
+    }
+  }
+}
+
+module.exports = { backup, restore, restoreIfMissing, PERSONALITY_DIR };

package/src/telegram/constants.js

@@ -3,7 +3,6 @@ const { TERM_WIDTH } = require('../status');
 const RATE_LIMIT_MS = 3000;
 const SPAM_THRESHOLD = 5;
 const SPAM_COOLDOWN_MS = 30000;
-const EVOLUTION_IDLE_MS = 15 * 60 * 1000;
 const DEDUP_TTL_MS = 5 * 60 * 1000;
 const DEDUP_MAX_SIZE = 2000;
 const TEXT_BUFFER_GAP_MS = 1500;
@@ -18,7 +17,6 @@ module.exports = {
   RATE_LIMIT_MS,
   SPAM_THRESHOLD,
   SPAM_COOLDOWN_MS,
-  EVOLUTION_IDLE_MS,
   DEDUP_TTL_MS,
   DEDUP_MAX_SIZE,
   TEXT_BUFFER_GAP_MS,

package/src/telegram/handlers/text.js

@@ -1,11 +1,9 @@
 const { InlineKeyboard } = require('grammy');
 const { getTenant } = require('../../tenant');
-const { evolve, loadEvolutionState } = require('../../evolve');
 const { buildStatusHtml, describeToolCall } = require('../../status');
 const { sendHtml, startTyping, splitMessage } = require('../utils');
-const { EVOLUTION_IDLE_MS, TEXT_BUFFER_GAP_MS, TEXT_BUFFER_MAX_PARTS, TEXT_BUFFER_MAX_CHARS, TEXT_BUFFER_THRESHOLD } = require('../constants');
+const { TEXT_BUFFER_GAP_MS, TEXT_BUFFER_MAX_PARTS, TEXT_BUFFER_MAX_CHARS, TEXT_BUFFER_THRESHOLD } = require('../constants');
 
-const _evolutionTimers = new Map();
 const textBuffers = new Map();
 const VERBOSE_FLUSH_MS = 2000;
 
@@ -141,12 +139,6 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
   const userId = ctx.from.id;
   const tenant = await getTenant(userId, config);
 
-  if (_evolutionTimers.has(userId)) {
-    clearTimeout(_evolutionTimers.get(userId));
-    _evolutionTimers.delete(userId);
-    if (tenant.messageLog) tenant.messageLog._evolutionPending = false;
-  }
-
   let replyContext = '';
   const reply = ctx.message?.reply_to_message;
   if (reply) {
@@ -214,55 +206,6 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
 
     tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
 
-    if (tenant.messageLog?._evolutionReady && !_evolutionTimers.has(userId)) {
-      tenant.messageLog._evolutionReady = false;
-      tenant.messageLog._evolutionPending = true;
-      const timer = setTimeout(async () => {
-        _evolutionTimers.delete(userId);
-        try {
-          const result = await evolve(tenant.claude.client, tenant.messageLog, tenant.memory, tenant.userDir);
-          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 && result.upgrades.length > 0) {
-            msg += '\n\n🆕 **New capabilities:**';
-            for (const u of result.upgrades) {
-              msg += `\n• **${u.name}** — ${u.description}`;
-              if (u.command) msg += ` → \`${u.command}\``;
-            }
-          }
-
-          if (result.deployedApps && result.deployedApps.length > 0) {
-            msg += '\n\n🚀 **Deployed:**';
-            for (const app of result.deployedApps) {
-              if (app.url) {
-                msg += `\n• ${app.name} → ${app.url}`;
-              } else if (app.error) {
-                msg += `\n• ${app.name} — deploy failed: ${app.error.substring(0, 100)}`;
-              }
-            }
-          }
-
-          if (result.changelog) {
-            msg += `\n\n_${result.changelog}_`;
-          }
-
-          await sendHtml(ctx, msg).catch(() => {});
-        } catch (e) {
-          console.error('Evolution failed:', e.message);
-        } finally {
-          tenant.messageLog._evolutionPending = false;
-        }
-      }, EVOLUTION_IDLE_MS);
-      _evolutionTimers.set(userId, timer);
-    }
-
     stopTyping();
 
     if (response.length > 4096) {

package/src/tenant.js

@@ -1,6 +1,9 @@
 const { ensureUserDir } = require('./config');
+const { PERSONALITY_DIR } = require('./soul');
 const { loadPersonality } = require('./personality');
 const { createMemory } = require('./memory');
+const { createSelfMemory } = require('./memory-self');
+const { createPatterns } = require('./patterns');
 const { createClaude } = require('./claude');
 const { createMessageLog } = require('./messages');
 const { BackgroundRunner } = require('./background');
@@ -30,13 +33,14 @@ _tenantCleanup.unref();
 
 async function createTenant(userId, config) {
   const userDir = ensureUserDir(userId);
-  const personalityDir = path.join(userDir, 'personality');
-  const personality = loadPersonality(personalityDir);
+  const personality = loadPersonality(PERSONALITY_DIR, path.join(userDir, 'personality'));
   const memory = config.supabase ? await createMemory(config.supabase, userId) : null;
+  const selfMemory = config.supabase ? await createSelfMemory(config.supabase, userId) : null;
+  const patterns = config.supabase ? await createPatterns(config.supabase, userId) : null;
   const bridgeEnabled = isBridgeEnabled(config) && (config.telegram?.allowedUsers?.length || 0) >= 2;
-  const claude = createClaude(config.anthropic, { personality, memory, userDir, bridgeEnabled, botName: config.bot?.name });
-  const messageLog = config.supabase ? createMessageLog(config.supabase, memory, config.anthropic, userId, userDir) : null;
+  const claude = createClaude(config.anthropic, { personality, memory, selfMemory, userDir, bridgeEnabled, botName: config.bot?.name });
   const scheduler = config.supabase ? createScheduler(config.supabase, userId) : null;
+  const messageLog = config.supabase ? createMessageLog(config.supabase, memory, config.anthropic, userId, userDir) : null;
   const toolPrefsApi = config.supabase ? createToolPrefs(config.supabase, userId) : null;
   const bg = new BackgroundRunner();
 
@@ -60,7 +64,7 @@ async function createTenant(userId, config) {
   } catch {}
 
   return {
-    claude, memory, messageLog, personality, scheduler, bg, userDir, userId,
+    claude, memory, selfMemory, patterns, messageLog, personality, scheduler, bg, userDir, userId,
     toolPrefs,
     toolPrefsApi,
     async reloadToolPrefs() {
@@ -78,9 +82,8 @@ async function getTenant(userId, config) {
   if (tenants.has(userId)) {
     const tenant = tenants.get(userId);
     if (Date.now() - (tenant._personalityLoadedAt || 0) > PERSONALITY_CACHE_TTL) {
-      const personalityDir = path.join(tenant.userDir, 'personality');
       try {
-        const soulPath = path.join(personalityDir, 'SOUL.md');
+        const soulPath = path.join(PERSONALITY_DIR, 'SOUL.md');
         const mtime = fs.statSync(soulPath).mtimeMs;
         if (mtime > (tenant._personalityMtime || 0)) {
           tenant.claude.reloadPersonality();