obol-ai 0.3.39 → 0.3.41

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.41
+- changelog
+- fix scheduler silent failures, remove haiku routing, improve memory format
+
+## 0.3.40
+- changelog
+- skip rate limiter for media group messages
+
 ## 0.3.39
 - changelog
 - sequential media downloads and image vision in read_file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.3.39",
+  "version": "0.3.41",
   "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
   "main": "src/index.js",
   "bin": {

package/src/claude/prompt.js

@@ -239,20 +239,38 @@ function withRuntimeContext(msgs, runtimePrefix) {
   return sanitizeMessages(copy);
 }
 
-function formatMemoryBlock(topFacts, selfFacts = []) {
-  let block = null;
-  if (topFacts.length > 0) {
-    const lines = topFacts.map(m => {
+function formatMemoryBlock(topFacts) {
+  if (!topFacts.length) return null;
+
+  const parts = [];
+
+  parts.push(`## Memory recall
+Retrieved from your persistent memory store. These facts were selected by a combination of recency (last 7 days) and semantic similarity to this conversation, then ranked by relevance, importance, and recency. Use them as context — they represent what you know about this person from past interactions.`);
+
+  const groups = {};
+  for (const m of topFacts) {
+    const cat = m.category || 'general';
+    if (!groups[cat]) groups[cat] = [];
+    groups[cat].push(m);
+  }
+
+  const order = ['person', 'preference', 'fact', 'goal', 'project', 'event', 'opinion', 'emotion', 'general'];
+  const sortedCats = Object.keys(groups).sort((a, b) => {
+    const ai = order.indexOf(a), bi = order.indexOf(b);
+    return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+  });
+
+  for (const cat of sortedCats) {
+    parts.push(`\n### ${cat}`);
+    const lines = groups[cat].map(m => {
       const date = m.created_at ? new Date(m.created_at).toISOString().slice(0, 10) : '';
-      return `- [${m.category}] ${m.content}${date ? ` (${date})` : ''}`;
+      const src = m.source ? ` [via ${m.source}]` : '';
+      return `- ${m.content}${date ? ` (${date})` : ''}${src}`;
     });
-    block = `## Relevant memories\n${lines.join('\n')}`;
-  }
-  if (selfFacts.length > 0) {
-    const selfLines = selfFacts.slice(0, 8).map(m => `- [${m.category}] ${m.content}`);
-    block = (block || '') + `\n\n## Self-knowledge\n${selfLines.join('\n')}`;
+    parts.push(lines.join('\n'));
   }
-  return block;
+
+  return parts.join('\n');
 }
 
 module.exports = { buildSystemPrompt, buildSystemBlock, buildRuntimePrefix, withRuntimeContext, formatMemoryBlock };

package/src/claude/router.js

@@ -24,36 +24,6 @@ function jaccardFromSets(setA, setB) {
   return inter / (setA.size + setB.size - inter);
 }
 
-const TOOL_PATTERNS = [
-  /\b(?:list|read|write|create|edit|delete|find|grep)\b.*\b(?:files?|folders?|director(?:y|ies)|scripts?|codebase)\b/,
-  /\b(?:run|execute)\b.*\b(?:tests?|suite|script|command)\b/,
-  /\b(?:save|store|remember)\b.*\b(?:note|that|memory|secret|password|key)\b/,
-  /\b(?:remind|schedule|set a reminder|cancel.*(?:event|reminder))\b/,
-  /\b(?:search the web|look up online|google)\b/,
-  /\b(?:deploy|build|install)\b.*\b(?:app|site|dashboard|project|package)\b/,
-  /\b(?:create|generate|make)\b.*\b(?:pdf|chart|diagram|flowchart|image)\b/,
-  /\b(?:what|which)\b.*\b(?:api keys?|secrets?|credentials?|reminders?|events?)\b.*\b(?:stored|have|set|coming)\b/,
-  /\b(?:what have you been|what are you)\b.*\b(?:research|learn|curious|explor)\b/,
-  /\b(?:email|e-mail|inbox|gmail|outlook|mail)\b/,
-  /\b(?:meeting|flight|appointment|deadline|booking|reservation|calendar|event|conference|itinerary)\b/,
-];
-
-function likelyNeedsTools(message) {
-  const lower = message.toLowerCase();
-  return TOOL_PATTERNS.some(p => p.test(lower));
-}
-
-function recentlyUsedTools(history) {
-  for (let i = history.length - 1; i >= Math.max(0, history.length - 4); i--) {
-    const msg = history[i];
-    if (msg.role === 'assistant' && Array.isArray(msg.content) &&
-        msg.content.some(b => b.type === 'tool_use')) {
-      return true;
-    }
-  }
-  return false;
-}
-
 async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision, onRouteUpdate, recentHistory = [], selfMemory = null }) {
   let memoryBlock = null;
   let model = null;
@@ -68,13 +38,13 @@ async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision
 2. What model complexity does it need?
 
 Reply with ONLY a JSON object:
-{"need_memory": true/false, "search_queries": ["query1", "query2"], "model": "haiku|sonnet|opus"}
+{"need_memory": true/false, "search_queries": ["query1", "query2"], "model": "sonnet|opus"}
 
 search_queries: 1-5 optimized search queries based on the full conversation context. Cover distinct topics, people, entities, time periods, or projects referenced. Single-topic messages need just one query. Use more queries when the message references multiple people, projects, or threads.
 
 Memory: casual messages (greetings, jokes, simple questions) → false. References to past, people, projects, preferences → true.
 
-Model: Default to "sonnet". Use "haiku" ONLY for: greetings, brief acknowledgments (thanks/ok/bye), casual chitchat, quick yes/no questions, and short single-turn exchanges that don't need any tool calling AND don't need memory. If need_memory is true, use "sonnet" minimum — haiku cannot reason over recalled context well enough. Use "sonnet" for: code generation, data analysis, content creation, explanations, creative writing, agentic tool use, general questions, opinions, advice, memory-dependent questions, and most conversational exchanges with substance. Use "opus" for: professional software engineering tasks, advanced multi-step agent work, complex reasoning, scientific or mathematical problems, tasks requiring nuanced understanding, advanced coding challenges, in-depth research, and architecture or design decisions.
+Model: Default to "sonnet". Use "sonnet" for: general conversation, code generation, data analysis, content creation, explanations, creative writing, agentic tool use, questions, opinions, advice, memory-dependent questions, and most exchanges. Use "opus" for: professional software engineering tasks, advanced multi-step agent work, complex reasoning, scientific or mathematical problems, tasks requiring nuanced understanding, advanced coding challenges, in-depth research, and architecture or design decisions.
 
 If recent context shows an ongoing task (sonnet/opus was just used, multi-step work in progress), bias toward that model even for short follow-up messages.`,
       messages: buildRouterMessages(recentHistory, userMessage),
@@ -91,33 +61,25 @@ If recent context shows an ongoing task (sonnet/opus was just used, multi-step w
       ? decision.search_queries.slice(0, 3)
       : decision.search_query ? [decision.search_query] : [];
 
-    if (decision.model === 'haiku' && likelyNeedsTools(userMessage)) {
-      vlog('[router] haiku overridden → sonnet (tool-need heuristic)');
+    if (decision.model !== 'sonnet' && decision.model !== 'opus') {
       decision.model = 'sonnet';
     }
 
-    if (decision.model === 'haiku' && recentlyUsedTools(recentHistory)) {
-      vlog('[router] haiku overridden → sonnet (recent tool use in history)');
-      decision.model = 'sonnet';
-    }
-
-    vlog(`[router] model=${decision.model || 'sonnet'} memory=${decision.need_memory || false}${queries.length ? ` queries=${JSON.stringify(queries)}` : ''}`);
+    vlog(`[router] model=${decision.model} memory=${decision.need_memory || false}${queries.length ? ` queries=${JSON.stringify(queries)}` : ''}`);
 
     onRouteDecision?.({
-      model: decision.model || 'sonnet',
+      model: decision.model,
       needMemory: decision.need_memory || false,
       memoryCount: 0,
     });
 
     if (decision.model === 'opus') {
       model = 'claude-opus-4-6';
-    } else if (decision.model === 'haiku') {
-      model = 'claude-haiku-4-5';
     }
 
     if (decision.need_memory && memory) {
-      const budget = decision.model === 'opus' ? 40 : decision.model === 'haiku' ? 15 : 25;
-      const poolPerQuery = decision.model === 'opus' ? 20 : decision.model === 'haiku' ? 10 : 15;
+      const budget = decision.model === 'opus' ? 60 : 40;
+      const poolPerQuery = decision.model === 'opus' ? 25 : 20;
       const searchQueries = queries.length > 0 ? queries : [userMessage];
 
       const recentMemories = await memory.byDate('7d', { limit: Math.ceil(budget / 3) });
@@ -153,22 +115,7 @@ If recent context shows an ongoing task (sonnet/opus was just used, multi-step w
       vlog(`[memory] ${topFacts.length} facts (${recentMemories.length} recent, ${semanticMemories.length} semantic, budget=${budget})`);
       onRouteUpdate?.({ memoryCount: topFacts.length });
 
-      let selfFacts = [];
-      if (selfMemory) {
-        const selfResults = await Promise.all(
-          searchQueries.map(q => selfMemory.search(q, { limit: 5, threshold: 0.4 }))
-        );
-        const seen2 = new Set();
-        for (const m of selfResults.flat()) {
-          if (!seen2.has(m.id)) { seen2.add(m.id); selfFacts.push(m); }
-        }
-        if (selfFacts.length > 0) {
-          vlog(`[memory] +${selfFacts.length} self-memory facts`);
-          onRouteUpdate?.({ selfMemoryCount: selfFacts.length });
-        }
-      }
-
-      memoryBlock = formatMemoryBlock(topFacts, selfFacts);
+      memoryBlock = formatMemoryBlock(topFacts);
     }
   } catch (e) {
     console.error('[router] Memory/routing decision failed:', e.message);

package/src/claude/tools/scheduler.js

@@ -33,7 +33,7 @@ Always search memory first for the user's timezone/location.`,
     input_schema: {
       type: 'object',
       properties: {
-        status: { type: 'string', enum: ['pending', 'sent', 'cancelled', 'completed'], description: 'Filter by status (default: pending)' },
+        status: { type: 'string', enum: ['pending', 'sent', 'cancelled', 'completed', 'failed'], description: 'Filter by status (default: pending)' },
         filters: { type: 'object', description: 'PostgREST column filters. Key = column name, value = operator.value. E.g. {"title":"like.*briefing*","cron_expr":"not.is.null","run_count":"gte.5"}', additionalProperties: { type: 'string' } },
         order: { type: 'string', description: 'Sort order: column.direction. E.g. "run_count.desc", "created_at.asc"' },
       },

package/src/db/migrate.js

@@ -287,6 +287,17 @@ async function migrate(supabaseConfig) {
       WHERE id = ANY(memory_ids);
     $$;`,
 
+    // Event retry tracking
+    `ALTER TABLE obol_events ADD COLUMN IF NOT EXISTS attempts INT NOT NULL DEFAULT 0;`,
+    `ALTER TABLE obol_events ADD COLUMN IF NOT EXISTS last_error TEXT;`,
+
+    `DO $$ BEGIN
+      ALTER TABLE obol_events DROP CONSTRAINT IF EXISTS obol_events_status_check;
+      ALTER TABLE obol_events ADD CONSTRAINT obol_events_status_check
+        CHECK (status IN ('pending','sent','cancelled','completed','failed'));
+    EXCEPTION WHEN undefined_object THEN NULL;
+    END $$;`,
+
     // Soul backup table (one row per file key: 'soul', 'agents')
     `CREATE TABLE IF NOT EXISTS obol_soul (
       id TEXT PRIMARY KEY,

package/src/runtime/heartbeat.js

@@ -18,7 +18,7 @@ const NEWS_HOURS = new Set([8, 18]);
 const _evolutionRunning = new Set();
 const _newsRunning = new Set();
 let _curiosityRunning = false;
-let _schedulerBusy = false;
+const _inflight = new Set();
 const _analysisRunning = new Set();
 
 function getLocalHour(timezone) {
@@ -210,7 +210,57 @@ async function runNewsForUser(bot, config, userId) {
   }
 }
 
-const STALE_EVENT_MS = 24 * 60 * 60 * 1000;
+const MAX_ATTEMPTS = 3;
+const STALE_MS = 2 * 60 * 60 * 1000;
+const EVENT_TIMEOUT_MS = 30_000;
+
+async function processEvent(bot, config, scheduler, event) {
+  const tz = event.timezone || 'UTC';
+  const age = Date.now() - new Date(event.due_at).getTime();
+
+  if (age > STALE_MS) {
+    console.warn(`[scheduler] Stale event ${event.id} "${event.title}" (due ${event.due_at})`);
+    if (event.cron_expr) {
+      await scheduler.reschedule(event.id, event.cron_expr, tz, event.run_count, event.max_runs, event.ends_at);
+    } else {
+      await scheduler.markFailed(event.id, 'Stale — exceeded 2h window');
+    }
+    return;
+  }
+
+  const attempts = (event.attempts || 0) + 1;
+  await scheduler.patch(event.id, { attempts });
+
+  try {
+    if (event.instructions) {
+      await runAgenticEvent(bot, config, event);
+    } else {
+      await sendReminderMessage(bot, event);
+    }
+
+    if (event.cron_expr) {
+      await scheduler.patch(event.id, { last_error: null });
+      await scheduler.reschedule(event.id, event.cron_expr, tz, event.run_count, event.max_runs, event.ends_at);
+    } else {
+      await scheduler.markSent(event.id);
+    }
+  } catch (e) {
+    const errMsg = (e.message || '').substring(0, 500);
+    console.error(`[scheduler] Event ${event.id} attempt ${attempts} failed:`, errMsg);
+    await scheduler.patch(event.id, { last_error: errMsg });
+
+    if (attempts >= MAX_ATTEMPTS) {
+      if (event.cron_expr) {
+        await scheduler.reschedule(event.id, event.cron_expr, tz, event.run_count, event.max_runs, event.ends_at);
+      } else {
+        await scheduler.markFailed(event.id, errMsg);
+      }
+      await bot.api.sendMessage(event.chat_id,
+        `⚠️ Scheduled event "${event.title}" failed: ${errMsg.substring(0, 200)}`
+      ).catch(() => {});
+    }
+  }
+}
 
 function setupHeartbeat(bot, config) {
   const supabaseConfig = config?.supabase;
@@ -228,43 +278,22 @@ function setupHeartbeat(bot, config) {
     }
 
     if (!scheduler || !bot) return;
-    if (_schedulerBusy) return;
-    _schedulerBusy = true;
 
     try {
-      const dueEvents = await scheduler.getDue();
+      const dueEvents = await scheduler.getDue(MAX_ATTEMPTS);
       if (dueEvents.length > 0) {
         console.log(`[scheduler] Processing ${dueEvents.length} due event(s)`);
       }
       for (const event of dueEvents) {
-        try {
-          const age = Date.now() - new Date(event.due_at).getTime();
-          if (age > STALE_EVENT_MS) {
-            console.warn(`[scheduler] Expiring stale event ${event.id} "${event.title}" (due ${event.due_at})`);
-            await scheduler.markSent(event.id);
-            continue;
-          }
-
-          if (event.instructions) {
-            await runAgenticEvent(bot, config, event);
-          } else {
-            await sendReminderMessage(bot, event);
-          }
-
-          const tz = event.timezone || 'UTC';
-          if (event.cron_expr) {
-            await scheduler.reschedule(event.id, event.cron_expr, tz, event.run_count, event.max_runs, event.ends_at);
-          } else {
-            await scheduler.markSent(event.id);
-          }
-        } catch (e) {
-          console.error(`[scheduler] Failed to process event ${event.id}:`, e.message);
-        }
+        if (_inflight.has(event.id)) continue;
+
+        _inflight.add(event.id);
+        processEvent(bot, config, scheduler, event)
+          .catch(e => console.error(`[scheduler] Unhandled error for event ${event.id}:`, e.message))
+          .finally(() => _inflight.delete(event.id));
       }
     } catch (e) {
       console.error('[scheduler] Failed to check due events:', e.message);
-    } finally {
-      _schedulerBusy = false;
     }
   });
 
@@ -381,12 +410,20 @@ async function runAgenticEvent(bot, config, event) {
     'Do NOT output JSON, code blocks, tool calls, or structured data. Write as a direct Telegram message.'
   );
 
-  const response = await tenant.claude.client.messages.create({
-    model: 'claude-sonnet-4-6',
-    max_tokens: 300,
-    system: systemParts.join('\n\n'),
-    messages: [{ role: 'user', content: event.instructions }],
-  });
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), EVENT_TIMEOUT_MS);
+
+  let response;
+  try {
+    response = await tenant.claude.client.messages.create({
+      model: 'claude-sonnet-4-6',
+      max_tokens: 300,
+      system: systemParts.join('\n\n'),
+      messages: [{ role: 'user', content: event.instructions }],
+    }, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
 
   const text = response.content.filter(b => b.type === 'text').map(b => b.text).join('\n').trim();
   if (!text) throw new Error('Empty response from model');

package/src/runtime/scheduler.js

@@ -62,9 +62,9 @@ function createScheduler(supabaseConfig, userId = 0) {
     return data[0];
   }
 
-  async function getDue() {
+  async function getDue(maxAttempts = 3) {
     const now = new Date().toISOString();
-    const fetchUrl = `${url}/rest/v1/obol_events?status=eq.pending&due_at=lte.${now}`;
+    const fetchUrl = `${url}/rest/v1/obol_events?status=eq.pending&due_at=lte.${now}&attempts=lt.${maxAttempts}`;
     const res = await fetch(fetchUrl, { headers, signal: AbortSignal.timeout(15000) });
     const data = await res.json();
     if (!res.ok) throw new Error(JSON.stringify(data));
@@ -88,6 +88,10 @@ function createScheduler(supabaseConfig, userId = 0) {
     return patch(eventId, { status: 'sent' });
   }
 
+  async function markFailed(eventId, error) {
+    return patch(eventId, { status: 'failed', last_error: (error || '').substring(0, 500) });
+  }
+
   async function reschedule(eventId, cronExpr, timezone, runCount, maxRuns, endsAt) {
     const newRunCount = (runCount || 0) + 1;
 
@@ -107,6 +111,7 @@ function createScheduler(supabaseConfig, userId = 0) {
         run_count: newRunCount,
         last_run_at: new Date().toISOString(),
         status: 'pending',
+        attempts: 0,
       });
     } catch (e) {
       console.error(`[scheduler] Failed to compute next cron occurrence for event ${eventId}:`, e.message);
@@ -126,7 +131,7 @@ function createScheduler(supabaseConfig, userId = 0) {
     return data[0];
   }
 
-  return { add, list, cancel, getDue, markSent, reschedule, update };
+  return { add, list, cancel, getDue, markSent, markFailed, patch, reschedule, update };
 }
 
 module.exports = { createScheduler };

package/src/telegram/handlers/media.js

@@ -166,13 +166,16 @@ function registerMediaHandler(bot, telegramConfig, deps) {
   async function handleMedia(ctx) {
     if (!ctx.from) return;
     const userId = ctx.from.id;
-    const { createRateLimiter } = require('../rate-limit');
-    if (!bot._rateLimiter) bot._rateLimiter = createRateLimiter();
-    const rateResult = bot._rateLimiter.check(userId);
-    if (rateResult) return;
     const fileInfo = media.getFileInfo(ctx);
     if (!fileInfo) return;
 
+    if (!ctx.message.media_group_id) {
+      const { createRateLimiter } = require('../rate-limit');
+      if (!bot._rateLimiter) bot._rateLimiter = createRateLimiter();
+      const rateResult = bot._rateLimiter.check(userId);
+      if (rateResult) return;
+    }
+
     if (fileInfo.fileSize > MAX_MEDIA_SIZE) {
       await ctx.reply(`File too large (${(fileInfo.fileSize / 1024 / 1024).toFixed(1)}MB). Max is 50MB.`).catch(() => {});
       return;