obol-ai 0.2.39 → 0.3.0

package/src/heartbeat.js

@@ -1,6 +1,149 @@
 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 { 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));
+  } 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 +195,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 +252,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 };

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