obol-ai 0.2.39 → 0.3.1

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-humor.js

@@ -0,0 +1,137 @@
+const HUMOR_MODEL = 'claude-sonnet-4-6';
+const MAX_ITERATIONS = 8;
+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 runCuriosityHumor(client, selfMemory, users) {
+  if (!users.length) return;
+
+  const userMap = new Map(users.map(u => [String(u.userId), u]));
+
+  const tools = [
+    { type: 'web_search_20250305', name: 'web_search' },
+    {
+      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 profile for a specific user — needed to craft inside jokes',
+      input_schema: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string', description: 'The user ID to get context for' },
+        },
+        required: ['user_id'],
+      },
+    },
+    {
+      name: 'schedule_humor',
+      description: 'Schedule a humorous moment to be delivered to 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 pun, funny connection, or inside joke — just the content itself. Can include a URL if a news article or link is part of what makes it funny.' },
+          delay: { type: 'string', description: 'When to drop 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. Now look at what you found and see if anything is funny — a pun you can make, a weird connection, something that'd land as an inside joke with a specific person based on who they are and what you know about them.\n\nUsers:\n${userList}\n\nBe picky. Only schedule something if it's actually clever. Forced humor is worse than none.`;
+
+  const messages = [{ role: 'user', content: 'Take a look at what you found and see if anything is worth a laugh.' }];
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const response = await client.messages.create({
+      model: HUMOR_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-humor] Humor 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_humor') {
+    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 spotted something funny during your own explorations: "${input.hint}". If the moment is right, drop it casually — a pun you just thought of, a funny connection, an inside reference. Don't explain it. Don't say it's a joke. Just let it land.`;
+
+    try {
+      await user.scheduler.add(user.chatId, 'Curiosity humor', dueAt, user.timezone, input.hint, null, null, null, instructions);
+      console.log(`[curiosity-humor] Scheduled humor for user ${input.user_id} at ${dueAt}`);
+      return 'Scheduled';
+    } catch (e) {
+      console.error(`[curiosity-humor] Failed to schedule humor for user ${input.user_id}:`, e.message);
+      return `Failed to schedule: ${e.message}`;
+    }
+  }
+
+  return 'Unknown tool';
+}
+
+module.exports = { runCuriosityHumor, resolveDelay, handleTool };

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