obol-ai 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "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/background.js

@@ -78,7 +78,7 @@ This helps track what you're doing. Complete the full task, then give the final
 TASK: ${task}`;
 
       const bgNotify = verboseNotify ? (msg) => verboseNotify(`[bg#${taskState.id}] ${msg}`) : undefined;
-      const result = await claude.chat(bgPrompt, {
+      const { text: result } = await claude.chat(bgPrompt, {
         chatId: `bg-${taskState.id}`,
         userName: 'BackgroundTask',
         verbose,
@@ -125,7 +125,7 @@ Give a ONE LINE progress update (emoji + what's happening). Be specific about wh
 
       // Use a separate quick call — don't interfere with the main task
       const checkInChatId = `checkin-${taskState.id}`;
-      const update = await claude.chat(checkInPrompt, {
+      const { text: update } = await claude.chat(checkInPrompt, {
         chatId: checkInChatId,
         userName: 'CheckIn',
       });
@@ -177,6 +177,7 @@ function formatDuration(seconds) {
 }
 
 async function sendLong(ctx, text) {
+  if (!text?.trim()) return;
   if (text.length <= 4096) {
     await ctx.reply(text, { parse_mode: 'Markdown' }).catch(() =>
       ctx.reply(text)

package/src/claude.js

@@ -5,6 +5,7 @@ const { execSync, execFileSync } = require('child_process');
 const { refreshTokens, isExpired, isOAuthToken } = require('./oauth');
 const { saveConfig, loadConfig, OBOL_DIR } = require('./config');
 const { execAsync, isAllowedUrl } = require('./sanitize');
+const { ChatHistory } = require('./history');
 
 const MAX_EXEC_TIMEOUT = 120;
 let MAX_TOOL_ITERATIONS = 100;
@@ -114,74 +115,14 @@ async function ensureFreshToken(anthropicConfig) {
   }
 }
 
-function repairHistory(history) {
-  const allToolUseIds = new Set();
-  for (const msg of history) {
-    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-      for (const b of msg.content) {
-        if (b.type === 'tool_use') allToolUseIds.add(b.id);
-      }
-    }
-  }
-
-  for (let i = history.length - 1; i >= 0; i--) {
-    const msg = history[i];
-    if (msg.role !== 'user' || !Array.isArray(msg.content)) continue;
-    const toolResults = msg.content.filter(b => b.type === 'tool_result');
-    if (toolResults.length === 0) continue;
-    const orphaned = toolResults.filter(b => !allToolUseIds.has(b.tool_use_id));
-    if (orphaned.length === 0) continue;
-    const remaining = msg.content.filter(b => b.type !== 'tool_result' || allToolUseIds.has(b.tool_use_id));
-    if (remaining.length === 0) {
-      history.splice(i, 1);
-    } else {
-      msg.content = remaining;
-    }
-  }
-
-  for (let i = 0; i < history.length; i++) {
-    const msg = history[i];
-    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
-    const toolUseIds = msg.content.filter(b => b.type === 'tool_use').map(b => b.id);
-    if (toolUseIds.length === 0) continue;
-    const next = history[i + 1];
-    if (next?.role === 'user' && Array.isArray(next.content)) {
-      const existingIds = new Set(next.content.filter(b => b.type === 'tool_result').map(b => b.tool_use_id));
-      const missingIds = toolUseIds.filter(id => !existingIds.has(id));
-      if (missingIds.length > 0) {
-        next.content = [
-          ...next.content,
-          ...missingIds.map(id => ({ type: 'tool_result', tool_use_id: id, content: '[interrupted]' })),
-        ];
-      }
-    } else {
-      const fakeResults = toolUseIds.map(id => ({
-        type: 'tool_result', tool_use_id: id, content: '[interrupted]',
-      }));
-      history.splice(i + 1, 0, { role: 'user', content: fakeResults });
-    }
-  }
-
-  for (let i = history.length - 1; i > 0; i--) {
-    if (history[i].role === history[i - 1].role && history[i].role === 'user') {
-      const prev = history[i - 1];
-      const curr = history[i];
-      const prevArr = Array.isArray(prev.content) ? prev.content : [{ type: 'text', text: prev.content }];
-      const currArr = Array.isArray(curr.content) ? curr.content : [{ type: 'text', text: curr.content }];
-      history[i - 1] = { role: 'user', content: [...prevArr, ...currArr] };
-      history.splice(i, 1);
-    }
-  }
-}
-
 function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR, bridgeEnabled }) {
   let client = createAnthropicClient(anthropicConfig);
 
   let baseSystemPrompt = buildSystemPrompt(personality, userDir, { bridgeEnabled });
 
-  const histories = new Map();
+  const histories = new ChatHistory(50);
   const chatLocks = new Map();
-  const MAX_HISTORY = 50;
+  const chatAbortControllers = new Map();
 
   const tools = buildTools(memory, { bridgeEnabled });
 
@@ -206,12 +147,13 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
     const chatId = context.chatId || 'default';
 
     if (isChatBusy(chatId)) {
-      return 'I\'m still working on the previous request. Give me a moment.';
+      return { text: 'I\'m still working on the previous request. Give me a moment.', usage: null, model: null };
     }
 
     const releaseLock = await acquireChatLock(chatId);
+    const abortController = new AbortController();
+    chatAbortControllers.set(chatId, abortController);
 
-    if (!histories.has(chatId)) histories.set(chatId, []);
     const history = histories.get(chatId);
 
     try {
@@ -296,41 +238,15 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
       }
     }
 
-    while (history.length >= MAX_HISTORY) {
-      let cut = 0;
-      while (cut < history.length - 1) {
-        const msg = history[cut];
-        cut++;
-        if (msg.role === 'assistant' && Array.isArray(msg.content) &&
-            msg.content.some(b => b.type === 'tool_use')) continue;
-        if (msg.role === 'user' && Array.isArray(msg.content) &&
-            msg.content.some(b => b.type === 'tool_result')) continue;
-        if (msg.role === 'assistant') break;
-      }
-      history.splice(0, cut);
-      if (cut === 0) { history.shift(); history.shift(); break; }
-    }
-    while (history.length > 0) {
-      const first = history[0];
-      if (first.role !== 'user') { history.shift(); continue; }
-      if (Array.isArray(first.content) && first.content.some(b => b.type === 'tool_result')) {
-        history.shift(); continue;
-      }
-      break;
-    }
-    repairHistory(history);
+    histories.prune(chatId);
 
-    // Add user message with memory context
     const enrichedMessage = memoryContext
       ? userMessage + memoryContext
       : userMessage;
     if (context.images?.length) {
-      history.push({
-        role: 'user',
-        content: [...context.images, { type: 'text', text: enrichedMessage }],
-      });
+      histories.pushUser(chatId, [...context.images, { type: 'text', text: enrichedMessage }]);
     } else {
-      history.push({ role: 'user', content: enrichedMessage });
+      histories.pushUser(chatId, enrichedMessage);
     }
 
     const model = context._model || 'claude-sonnet-4-6';
@@ -345,50 +261,70 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
       messages: [...history],
       tools: runnableTools.length > 0 ? runnableTools : undefined,
       max_iterations: MAX_TOOL_ITERATIONS,
-    });
+    }, { signal: abortController.signal });
 
     let finalMessage;
+    let totalUsage = { input_tokens: 0, output_tokens: 0 };
     for await (const message of runner) {
       finalMessage = message;
       if (message.usage) {
+        totalUsage.input_tokens += message.usage.input_tokens || 0;
+        totalUsage.output_tokens += message.usage.output_tokens || 0;
         vlog(`[tokens] in=${message.usage.input_tokens} out=${message.usage.output_tokens}`);
       }
     }
 
     const runnerMessages = runner.params.messages;
     const newMessages = runnerMessages.slice(history.length);
-    for (const msg of newMessages) {
-      history.push(msg);
-    }
+    histories.pushMessages(chatId, newMessages);
 
     if (finalMessage.stop_reason === 'tool_use') {
       const bailoutResults = finalMessage.content
         .filter(b => b.type === 'tool_use')
         .map(b => ({ type: 'tool_result', tool_use_id: b.id, content: '[max tool iterations reached]' }));
-      history.push({ role: 'user', content: [
+      histories.pushUser(chatId, [
         ...bailoutResults,
         { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
-      ] });
+      ]);
       const bailoutResponse = await client.messages.create({
-        model, max_tokens: 4096, system: systemPrompt, messages: history,
-      });
-      history.push({ role: 'assistant', content: bailoutResponse.content });
-      return bailoutResponse.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+        model, max_tokens: 4096, system: systemPrompt, messages: [...histories.get(chatId)],
+      }, { signal: abortController.signal });
+      histories.pushAssistant(chatId, bailoutResponse.content);
+      if (bailoutResponse.usage) {
+        totalUsage.input_tokens += bailoutResponse.usage.input_tokens || 0;
+        totalUsage.output_tokens += bailoutResponse.usage.output_tokens || 0;
+      }
+      const text = bailoutResponse.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+      return { text, usage: totalUsage, model };
     }
 
-    return finalMessage.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    const text = finalMessage.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    return { text, usage: totalUsage, model };
 
     } catch (e) {
+      if (e.message === 'Request was aborted.' || e.constructor?.name === 'APIUserAbortError') {
+        return { text: null, usage: null, model: null };
+      }
       if (e.status === 400 && e.message?.includes('tool_use')) {
         console.error('[claude] Repairing corrupted history after 400 error');
-        repairHistory(history);
+        histories.repair(chatId);
       }
       throw e;
     } finally {
+      chatAbortControllers.delete(chatId);
       releaseLock();
     }
   }
 
+  function stopChat(chatId) {
+    const controller = chatAbortControllers.get(chatId);
+    if (controller) {
+      controller.abort();
+      return true;
+    }
+    return false;
+  }
+
   function reloadPersonality() {
     const pDir = userDir ? path.join(userDir, 'personality') : undefined;
     const newPersonality = require('./personality').loadPersonality(pDir);
@@ -406,33 +342,15 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
   }
 
   function injectHistory(chatId, role, content) {
-    if (!histories.has(chatId)) histories.set(chatId, []);
-    const history = histories.get(chatId);
-    history.push({ role, content });
+    histories.inject(chatId, role, content);
   }
 
   function getContextStats(chatId) {
     const id = chatId || 'default';
-    const history = histories.get(id) || [];
-    const MAX_CONTEXT = 200000;
-    let chars = baseSystemPrompt.length;
-    for (const msg of history) {
-      if (typeof msg.content === 'string') {
-        chars += msg.content.length;
-      } else if (Array.isArray(msg.content)) {
-        for (const b of msg.content) {
-          if (b.text) chars += b.text.length;
-          else if (b.content) chars += (typeof b.content === 'string' ? b.content.length : JSON.stringify(b.content).length);
-          else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length + (b.name?.length || 0);
-        }
-      }
-    }
-    const estimatedTokens = Math.round(chars / 4);
-    const pct = Math.min(100, Math.round((estimatedTokens / MAX_CONTEXT) * 100));
-    return { messages: history.length, estimatedTokens, maxTokens: MAX_CONTEXT, pct };
+    return histories.estimateTokens(id, baseSystemPrompt.length);
   }
 
-  return { chat, client, reloadPersonality, clearHistory, injectHistory, getContextStats };
+  return { chat, client, reloadPersonality, clearHistory, injectHistory, getContextStats, stopChat };
 }
 
 function buildSystemPrompt(personality, userDir, opts = {}) {
@@ -588,6 +506,14 @@ Examples:
 
 Returns the tapped button label, or \`"timeout"\` if the user doesn't respond within the timeout (default 60s).
 
+### Scheduling (\`schedule_event\`, \`list_events\`, \`cancel_event\`)
+Schedule reminders and events. The user gets a Telegram message when the time comes.
+- \`schedule_event\` — schedule a reminder with title, due_at (ISO 8601), timezone (IANA), optional description
+- \`list_events\` — list pending/sent/cancelled events
+- \`cancel_event\` — cancel a scheduled event by ID
+
+When scheduling: always search memory first for the user's timezone/location. If no timezone found, ask the user or default to UTC. Parse natural language dates relative to the user's timezone.
+
 ### Bridge (\`bridge_ask\`, \`bridge_tell\`)
 Only available if bridge is enabled. Communicate with partner's AI agent.
 `);
@@ -859,6 +785,44 @@ function buildTools(memory, opts = {}) {
     },
   });
 
+  tools.push({
+    name: 'schedule_event',
+    description: 'Schedule a reminder or event. The user will receive a Telegram message when the time comes. Always search memory first for the user\'s timezone/location. If no timezone found, ask the user or default to UTC.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Short title for the reminder/event' },
+        due_at: { type: 'string', description: 'ISO 8601 datetime string for when the event is due (e.g. 2026-02-25T15:00:00)' },
+        timezone: { type: 'string', description: 'IANA timezone (e.g. Europe/Brussels, America/New_York). Default: UTC' },
+        description: { type: 'string', description: 'Context or details about the event. Always include relevant info from the conversation (e.g. what to do, who it involves, where).' },
+      },
+      required: ['title', 'due_at'],
+    },
+  });
+
+  tools.push({
+    name: 'list_events',
+    description: 'List scheduled events/reminders for the user.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['pending', 'sent', 'cancelled'], description: 'Filter by status (default: pending)' },
+      },
+    },
+  });
+
+  tools.push({
+    name: 'cancel_event',
+    description: 'Cancel a scheduled event/reminder by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        event_id: { type: 'string', description: 'UUID of the event to cancel' },
+      },
+      required: ['event_id'],
+    },
+  });
+
   if (opts.bridgeEnabled) {
     const { buildBridgeTool, buildBridgeTellTool } = require('./bridge');
     tools.push(buildBridgeTool());
@@ -879,6 +843,8 @@ function buildRunnableTools(tools, memory, context, vlog) {
         tool.name === 'memory_add' ? `[${input.category || 'fact'}]` :
         tool.name === 'web_fetch' ? input.url :
         tool.name === 'background_task' ? input.task?.substring(0, 60) :
+        tool.name === 'schedule_event' ? `${input.title} @ ${input.due_at}` :
+        tool.name === 'cancel_event' ? input.event_id :
         JSON.stringify(input).substring(0, 80);
       vlog(`[tool] ${tool.name}: ${inputSummary}`);
       return await executeToolCall({ name: tool.name, input }, memory, context);
@@ -1106,6 +1072,39 @@ async function executeToolCall(toolUse, memory, context = {}) {
         return await bridgeTell(input.message, context.userId, context.config, context._notifyFn, input.partner_id);
       }
 
+      case 'schedule_event': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const tz = input.timezone || 'UTC';
+        const localDate = new Date(input.due_at);
+        if (isNaN(localDate.getTime())) return `Invalid date: ${input.due_at}`;
+        const utcDate = toUTC(input.due_at, tz);
+        const event = await context.scheduler.add(context.chatId, input.title, utcDate, tz, input.description || null);
+        const displayTime = new Date(utcDate).toLocaleString('en-US', { timeZone: tz });
+        return `Scheduled: "${input.title}" for ${displayTime} (${tz}) — ID: ${event.id}`;
+      }
+
+      case 'list_events': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const events = await context.scheduler.list({ status: input.status });
+        if (events.length === 0) return `No ${input.status || 'pending'} events.`;
+        return JSON.stringify(events.map(e => ({
+          id: e.id,
+          title: e.title,
+          description: e.description,
+          due_at: e.due_at,
+          timezone: e.timezone,
+          due_local: new Date(e.due_at).toLocaleString('en-US', { timeZone: e.timezone }),
+          status: e.status,
+        })));
+      }
+
+      case 'cancel_event': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const cancelled = await context.scheduler.cancel(input.event_id);
+        if (!cancelled) return `Event not found or not yours: ${input.event_id}`;
+        return `Cancelled: "${cancelled.title}"`;
+      }
+
       default:
         return `Unknown tool: ${name}`;
     }
@@ -1114,6 +1113,25 @@ async function executeToolCall(toolUse, memory, context = {}) {
   }
 }
 
+function toUTC(dateStr, timezone) {
+  const match = dateStr.match(/(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):?(\d{2})?/);
+  if (!match) return new Date(dateStr + 'Z').toISOString();
+  const [, y, mo, d, h, mi, s] = match;
+  const wallAsUTC = Date.UTC(+y, +mo - 1, +d, +h, +mi, +(s || 0));
+  if (timezone === 'UTC') return new Date(wallAsUTC).toISOString();
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit',
+    hour12: false,
+  });
+  const parts = fmt.formatToParts(new Date(wallAsUTC));
+  const get = (type) => parts.find(p => p.type === type)?.value || '00';
+  const hr = +get('hour') === 24 ? 0 : +get('hour');
+  const tzWall = Date.UTC(+get('year'), +get('month') - 1, +get('day'), hr, +get('minute'), +get('second'));
+  return new Date(wallAsUTC - (tzWall - wallAsUTC)).toISOString();
+}
+
 function getMaxToolIterations() { return MAX_TOOL_ITERATIONS; }
 function setMaxToolIterations(n) { MAX_TOOL_ITERATIONS = n; }
 

package/src/db/migrate.js

@@ -130,6 +130,38 @@ async function migrate(supabaseConfig) {
       CREATE POLICY "service_role_all" ON obol_messages FOR ALL TO service_role USING (true) WITH CHECK (true);
     EXCEPTION WHEN duplicate_object THEN NULL;
     END $$;`,
+
+    // Events table (scheduling & reminders)
+    `CREATE TABLE IF NOT EXISTS obol_events (
+      id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+      user_id BIGINT NOT NULL,
+      chat_id BIGINT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      due_at TIMESTAMPTZ NOT NULL,
+      timezone TEXT NOT NULL DEFAULT 'UTC',
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','cancelled')),
+      created_at TIMESTAMPTZ DEFAULT NOW()
+    );`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_events_due ON obol_events (due_at) WHERE status = 'pending';`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_events_user ON obol_events (user_id);`,
+    `ALTER TABLE obol_events ENABLE ROW LEVEL SECURITY;`,
+    `DO $$ BEGIN
+      CREATE POLICY "service_role_all" ON obol_events FOR ALL TO service_role USING (true) WITH CHECK (true);
+    EXCEPTION WHEN duplicate_object THEN NULL;
+    END $$;`,
+
+    // Drop redundant user_id from obol_messages (chat_id == user_id for Telegram private chats)
+    `DROP INDEX IF EXISTS idx_obol_messages_user;`,
+    `ALTER TABLE obol_messages DROP COLUMN IF EXISTS user_id;`,
+
+    // Atomic access count increment for memory search hits
+    `CREATE OR REPLACE FUNCTION increment_memory_access(memory_ids UUID[])
+    RETURNS VOID LANGUAGE SQL AS $$
+      UPDATE obol_memory
+      SET access_count = access_count + 1, accessed_at = NOW()
+      WHERE id = ANY(memory_ids);
+    $$;`,
   ];
 
   // Save SQL file for manual fallback
@@ -148,24 +180,24 @@ async function migrate(supabaseConfig) {
   }
 
   const projectRef = url.replace('https://', '').replace('.supabase.co', '');
+  const batchedSql = sqlStatements.join('\n\n');
 
-  for (const sql of sqlStatements) {
-    try {
-      const res = await fetch(`https://api.supabase.com/v1/projects/${projectRef}/database/query`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${accessToken}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ query: sql }),
-      });
-      if (!res.ok) {
-        const err = await res.text();
-        console.log(`  ⚠️  SQL warning: ${err.substring(0, 100)}`);
-      }
-    } catch (e) {
-      console.log(`  ⚠️  Migration step failed: ${e.message}`);
+  try {
+    const res = await fetch(`https://api.supabase.com/v1/projects/${projectRef}/database/query`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query: batchedSql }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      console.log(`  ⚠️  Migration warning: ${err.substring(0, 200)}`);
     }
+  } catch (e) {
+    console.log(`  ⚠️  Migration failed: ${e.message}`);
   }
 }
 

package/src/evolve.js

@@ -106,7 +106,8 @@ function syncDir(dir, files) {
   }
   for (const f of fs.readdirSync(dir)) {
     if (!(f in files)) {
-      fs.unlinkSync(path.join(dir, f));
+      const full = path.join(dir, f);
+      fs.rmSync(full, { recursive: true, force: true });
     }
   }
 }
@@ -166,6 +167,84 @@ async function backupSnapshot(message, userDir) {
   } catch {}
 }
 
+async function deepConsolidateMemory(claudeClient, memory, messages, evolutionNumber) {
+  const transcript = messages.map(m =>
+    `${m.role === 'user' ? 'Human' : 'Bot'}: ${m.content.substring(0, 800)}`
+  ).join('\n');
+
+  const response = await claudeClient.messages.create({
+    model: MODELS.personality,
+    max_tokens: 4096,
+    system: `You are doing a deep memory extraction pass during an AI evolution cycle. Extract ALL valuable information from this full conversation history.
+
+Return JSON:
+{
+  "memories": [
+    {
+      "content": "specific, detailed fact",
+      "category": "fact|preference|decision|lesson|person|project|event|conversation|resource|pattern|context",
+      "tags": ["tag1", "tag2"],
+      "importance": 0.5
+    }
+  ]
+}
+
+Extract everything worth remembering long-term:
+- Personal details (identity, demographics, location, family, relationships)
+- Every preference and opinion expressed
+- All projects, goals, tasks and their status
+- Technical details (stack, tools, services, APIs)
+- Plans, intentions, next steps
+- Recurring themes and behavioral patterns across the full history
+- Emotional tone and communication preferences
+- Decisions and their reasoning
+- Resources and services mentioned
+- Events, dates, timelines
+- Lessons or realizations
+
+Tags: 2-5 specific lowercase keywords.
+Importance: 0.3 minor detail, 0.5 useful, 0.7 important, 0.9 critical.
+
+Be thorough — this is a Sonnet deep pass over the full history, not a quick Haiku scan.
+Skip only pure content-free exchanges ("hi", "ok", "bye").`,
+    messages: [{ role: 'user', content: transcript }],
+  });
+
+  const text = response.content[0]?.text || '';
+  const jsonMatch = text.match(/```json?\s*\n?([\s\S]*?)\n?\s*```/) || text.match(/\{[\s\S]*"memories"\s*:\s*\[[\s\S]*?\]\s*\}/);
+  if (!jsonMatch) return 0;
+
+  let extracted;
+  try {
+    extracted = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+  } catch {
+    return 0;
+  }
+
+  if (!extracted.memories?.length) return 0;
+
+  const validCategories = new Set(['fact','preference','decision','lesson','person','project','event','conversation','resource','pattern','context','email']);
+  let stored = 0;
+  for (const mem of extracted.memories) {
+    if (!mem.content || mem.content.length <= 10) continue;
+    try {
+      const existing = await memory.search(mem.content, { limit: 1, threshold: 0.92 });
+      if (existing.length > 0) continue;
+    } catch {}
+    const category = validCategories.has(mem.category) ? mem.category : 'fact';
+    const tags = Array.isArray(mem.tags) ? mem.tags.slice(0, 5) : [];
+    const importance = typeof mem.importance === 'number' ? Math.min(1, Math.max(0, mem.importance)) : 0.5;
+    await memory.add(mem.content, {
+      category,
+      tags,
+      importance,
+      source: `evolution-${evolutionNumber}`,
+    }).catch(() => {});
+    stored++;
+  }
+  return stored;
+}
+
 async function evolve(claudeClient, messageLog, memory, userDir) {
   const baseDir = userDir || OBOL_DIR;
   const state = loadEvolutionState(userDir);
@@ -255,6 +334,13 @@ async function evolve(claudeClient, messageLog, memory, userDir) {
   // ── Step 0: Snapshot before evolution ──
   await backupSnapshot(`pre-evolution #${evolutionNumber}`, userDir);
 
+  // ── Step 0b: Deep memory consolidation with Sonnet ──
+  if (memory && recentMessages.length >= 4) {
+    await deepConsolidateMemory(claudeClient, memory, recentMessages, evolutionNumber).catch(e =>
+      console.error('[evolve] Deep consolidation failed:', e.message)
+    );
+  }
+
   // ── Step 1: Run existing tests as baseline ──
   const baselineResults = runTests(testsDir);
 

package/src/heartbeat.js

@@ -1,11 +1,46 @@
 const cron = require('node-cron');
+const { createScheduler } = require('./scheduler');
 
-function setupHeartbeat() {
-  cron.schedule('*/30 * * * *', async () => {
-    console.log(`[${new Date().toISOString()}] Heartbeat tick`);
+function setupHeartbeat(bot, supabaseConfig) {
+  let scheduler = null;
+  if (supabaseConfig?.url && supabaseConfig?.serviceKey) {
+    scheduler = createScheduler(supabaseConfig);
+  }
+
+  let tickCount = 0;
+
+  cron.schedule('* * * * *', async () => {
+    tickCount++;
+    if (tickCount % 30 === 0) {
+      console.log(`[${new Date().toISOString()}] Heartbeat tick`);
+    }
+
+    if (!scheduler || !bot) return;
+
+    try {
+      const dueEvents = await scheduler.getDue();
+      for (const event of dueEvents) {
+        try {
+          const tz = event.timezone || 'UTC';
+          const dueLocal = new Date(event.due_at).toLocaleString('en-US', { timeZone: tz });
+          let text = `⏰ *Reminder:* ${event.title}`;
+          if (event.description) text += `\n${event.description}`;
+          text += `\n_${dueLocal} (${tz})_`;
+
+          await bot.api.sendMessage(event.chat_id, text, { parse_mode: 'Markdown' }).catch(() =>
+            bot.api.sendMessage(event.chat_id, `⏰ Reminder: ${event.title}${event.description ? '\n' + event.description : ''}`)
+          );
+          await scheduler.markSent(event.id);
+        } catch (e) {
+          console.error(`[scheduler] Failed to send event ${event.id}:`, e.message);
+        }
+      }
+    } catch (e) {
+      console.error('[scheduler] Failed to check due events:', e.message);
+    }
   });
 
-  console.log('  ✅ Heartbeat running (every 30min)');
+  console.log('  ✅ Heartbeat running (every 1min)');
 }
 
 module.exports = { setupHeartbeat };