obol-ai 0.2.39 → 0.3.1

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.3.1
+- update changelog
+- add curiosity humor pass with puns, inside jokes, and link support
+
+## 0.3.0
+- add tests for memory-self and analysis helpers
+- fix proactivity and memory bugs
+- add curiosity dispatch pass to schedule insights after curiosity cycle
+- run curiosity once per cycle with shared brain and all-user context
+- add curiosity engine with free-form exploration and own knowledge tools
+- add friendship behavior section and soften privacy rule for multi-user model
+- add proactive behavior + multi-user friend model to system prompt
+- add tests for silent mode, soul backup/restore, and shared personality dir
+- move SOUL.md to shared root dir with Supabase backup/restore
+- add silent mode for heartbeat-triggered background tasks
+- enrich analysis with memory search and pattern context
+- add analysis, patterns, self-memory, and proactive vector context
+- update changelog
+
 ## 0.2.39
 - use bot name from config in all telegram status messages
 - update changelog

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.39",
+  "version": "0.3.1",
   "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/analysis.js

@@ -0,0 +1,191 @@
+const ANALYSIS_WINDOW_MS = 3 * 60 * 60 * 1000;
+const MAX_MESSAGE_CHARS = 1000;
+const MAX_TRANSCRIPT_CHARS = 40000;
+
+async function runAnalysis(client, messageLog, scheduler, patterns, memory, userId, chatId, timezone) {
+  const since = new Date(Date.now() - ANALYSIS_WINDOW_MS);
+  const messages = await messageLog.getSince(chatId, since);
+
+  if (messages.length === 0) {
+    console.log(`[analysis] No messages in last 3h for user ${userId}`);
+    return;
+  }
+
+  console.log(`[analysis] Analyzing ${messages.length} messages for user ${userId}`);
+
+  const transcript = buildTranscript(messages);
+  const report = await generateReport(client, memory, transcript, timezone);
+  if (!report) return;
+
+  await structureReport(client, report, scheduler, patterns, chatId, timezone);
+
+  console.log(`[analysis] Complete for user ${userId}`);
+}
+
+function buildTranscript(messages) {
+  let transcript = '';
+  for (const msg of messages) {
+    const ts = new Date(msg.created_at).toLocaleString('en-US');
+    const content = msg.content.substring(0, MAX_MESSAGE_CHARS);
+    transcript += `[${ts}] ${msg.role.toUpperCase()}: ${content}\n\n`;
+    if (transcript.length > MAX_TRANSCRIPT_CHARS) break;
+  }
+  return transcript.trim();
+}
+
+async function generateReport(client, memory, transcript, timezone) {
+  const tools = memory ? [{
+    name: 'memory_search',
+    description: 'Search long-term memory for context about a topic in this transcript',
+    input_schema: {
+      type: 'object',
+      properties: { query: { type: 'string' } },
+      required: ['query'],
+    },
+  }] : [];
+
+  const system = `You are an attentive observer analyzing a conversation transcript. Write a free-form analytical report covering:
+
+1. INTENTIONS & FOLLOW-UPS: Any intentions expressed, upcoming events, pending tasks, or things worth a natural check-in later. Be selective — only things a friend would genuinely remember.
+
+2. BEHAVIORAL PATTERNS:
+   - Timing: when they tend to message, active windows, energy by day/time
+   - Mood signals: emotional baseline, stress indicators, good/bad day signals
+   - Humor style: what lands, banter comfort, comedic preferences
+   - Engagement depth: which topics generate longer responses, what they bring up unprompted
+   - Communication style: message length, formality, response patterns
+   - Recurring topics: what keeps coming up, what lights them up, what they avoid
+
+Write candidly and specifically. "Active between 9-11pm" beats "sometimes active at night". Skip categories with no signal. Timezone context: ${timezone}.${memory ? ' Use the memory_search tool to look up relevant context about topics in the transcript before writing your report.' : ''}`;
+
+  const messages = [{ role: 'user', content: `Conversation transcript:\n\n${transcript}` }];
+
+  try {
+    for (let i = 0; i < 6; i++) {
+      const response = await client.messages.create({
+        model: 'claude-sonnet-4-6',
+        max_tokens: 2000,
+        system,
+        ...(tools.length ? { tools, tool_choice: { type: 'auto' } } : {}),
+        messages,
+      });
+
+      const text = response.content.find(b => b.type === 'text');
+      if (text) return text.text;
+
+      const toolUses = response.content.filter(b => b.type === 'tool_use');
+      if (!toolUses.length) return null;
+
+      messages.push({ role: 'assistant', content: response.content });
+      const results = [];
+      for (const tu of toolUses) {
+        const hits = await memory.search(tu.input.query, { limit: 5 }).catch(() => []);
+        results.push({
+          type: 'tool_result',
+          tool_use_id: tu.id,
+          content: hits.length ? hits.map(m => `- ${m.content}`).join('\n') : 'No relevant memories found',
+        });
+      }
+      messages.push({ role: 'user', content: results });
+    }
+
+    return null;
+  } catch (e) {
+    console.error('[analysis] Report generation failed:', e.message);
+    return null;
+  }
+}
+
+async function structureReport(client, report, scheduler, patterns, chatId, timezone) {
+  const formattedPatterns = patterns
+    ? await patterns.format().catch(() => null)
+    : null;
+
+  const saveTool = [{
+    name: 'save_analysis',
+    description: 'Save structured analysis data from the analytical report',
+    input_schema: {
+      type: 'object',
+      properties: {
+        follow_ups: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              description: { type: 'string' },
+              delay: { type: 'string', description: '"2h", "1d", "3d", or "1w"' },
+              context: { type: 'string', description: 'Brief context for the follow-up message' },
+            },
+            required: ['description', 'delay', 'context'],
+          },
+        },
+        patterns: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              key: { type: 'string', description: 'Stable identifier e.g. "timing.active_hours"' },
+              dimension: { type: 'string', enum: ['timing', 'mood', 'humor', 'engagement', 'communication', 'topics'] },
+              summary: { type: 'string', description: 'Human-readable statement e.g. "Usually active 7-10pm"' },
+              data: { type: 'object', description: 'Structured supporting data' },
+              confidence: { type: 'number', description: '0-1' },
+            },
+            required: ['key', 'dimension', 'summary', 'confidence'],
+          },
+        },
+      },
+      required: ['follow_ups', 'patterns'],
+    },
+  }];
+
+  try {
+    const system = formattedPatterns
+      ? `Existing behavioral patterns for this user:\n${formattedPatterns}\n\n---\n\nConvert this analytical report into structured data using the save_analysis tool. Use existing patterns to calibrate confidence scores (higher if confirming, consider skipping if already well-established at >0.8). Flag contradictions in pattern data.`
+      : 'Convert this analytical report into structured data using the save_analysis tool. Extract all follow-ups and patterns mentioned.';
+
+    const response = await client.messages.create({
+      model: 'claude-sonnet-4-6',
+      max_tokens: 2000,
+      system,
+      tools: saveTool,
+      tool_choice: { type: 'tool', name: 'save_analysis' },
+      messages: [{ role: 'user', content: report }],
+    });
+
+    const toolUse = response.content.find(b => b.type === 'tool_use' && b.name === 'save_analysis');
+    if (!toolUse) return;
+
+    const followUps = toolUse.input?.follow_ups || [];
+    const patternList = toolUse.input?.patterns || [];
+
+    for (const fu of followUps) {
+      if (!fu.description || !fu.delay) continue;
+      const dueAt = resolveDelay(fu.delay);
+      const instructions = `You mentioned checking in on: "${fu.description}". Context: ${fu.context || ''}. Reach out naturally — like a friend who remembered. Keep it casual, one line. Don't reference any system or task.`;
+      await scheduler.add(chatId, 'Proactive follow-up', dueAt, timezone, fu.description, null, null, null, instructions).catch(e =>
+        console.error('[analysis] Failed to schedule follow-up:', e.message)
+      );
+    }
+
+    for (const p of patternList) {
+      if (!p.key || !p.dimension || !p.summary) continue;
+      await patterns.upsert(p.key, p.dimension, p.summary, p.data || {}, p.confidence || 0.5).catch(e =>
+        console.error('[analysis] Failed to upsert pattern:', e.message)
+      );
+    }
+
+    console.log(`[analysis] Saved ${followUps.length} follow-ups, ${patternList.length} patterns`);
+  } catch (e) {
+    console.error('[analysis] Structuring failed:', e.message);
+  }
+}
+
+function resolveDelay(delay) {
+  const now = Date.now();
+  const units = { h: 3600000, d: 86400000, w: 604800000 };
+  const match = delay.match(/^(\d+)([hdw])$/);
+  if (!match) return new Date(now + 86400000).toISOString();
+  return new Date(now + parseInt(match[1]) * units[match[2]]).toISOString();
+}
+
+module.exports = { runAnalysis, buildTranscript, resolveDelay };

package/src/background.js

@@ -30,13 +30,13 @@ class BackgroundRunner {
     const verbose = parentContext?.verbose || false;
     const verboseNotify = parentContext?._verboseNotify;
 
-    const promise = this._runTask(claude, task, taskState, ctx, memory, verbose, verboseNotify, opts.model, opts.extraContext || extraContext);
+    const promise = this._runTask(claude, task, taskState, ctx, memory, verbose, verboseNotify, opts.model, opts.extraContext || extraContext, opts.silent || false);
     taskState.promise = promise;
 
     return taskId;
   }
 
-  async _runTask(claude, task, taskState, ctx, memory, verbose, verboseNotify, model, extraContext = {}) {
+  async _runTask(claude, task, taskState, ctx, memory, verbose, verboseNotify, model, extraContext = {}, silent = false) {
     let statusMsgId = null;
     let statusTimer = null;
     let statusStart = Date.now();
@@ -50,7 +50,7 @@ class BackgroundRunner {
     };
 
     const startStatusTimer = () => {
-      if (statusTimer) return;
+      if (silent || statusTimer) return;
       const html = buildStatusHtml({ route: routeInfo, elapsed: 0, toolStatus: statusText, title });
       ctx.reply(html, { parse_mode: 'HTML' }).then(sent => {
         if (sent) statusMsgId = sent.message_id;
@@ -63,7 +63,7 @@ class BackgroundRunner {
       }, 5000);
     };
 
-    startStatusTimer();
+    if (!silent) startStatusTimer();
 
     try {
       const bgPrompt = `You are working on a background task. Do the work thoroughly.
@@ -103,8 +103,12 @@ TASK: ${task}`;
       clearStatus();
 
       const elapsed = Math.floor((Date.now() - taskState.startedAt) / 1000);
-      const header = `✅ <b>BG #${taskState.id}</b> done (${formatDuration(elapsed)})\n\n`;
-      await sendLong(ctx, header + result);
+      if (silent) {
+        await sendLong(ctx, result);
+      } else {
+        const header = `✅ <b>BG #${taskState.id}</b> done (${formatDuration(elapsed)})\n\n`;
+        await sendLong(ctx, header + result);
+      }
 
       if (memory) {
         await memory.add(`Background task completed: "${task.substring(0, 100)}". Took ${elapsed}s.`, {
@@ -119,7 +123,11 @@ TASK: ${task}`;
       taskState.status = 'error';
       taskState.error = e.message;
       clearStatus();
-      await ctx.reply(`⚠️ BG #${taskState.id} failed: ${e.message}`).catch(() => {});
+      if (!silent) {
+        await ctx.reply(`⚠️ BG #${taskState.id} failed: ${e.message}`).catch(() => {});
+      } else {
+        console.error(`[bg#${taskState.id}] Silent task failed: ${e.message}`);
+      }
     }
   }
 

package/src/claude/chat.js

@@ -8,7 +8,7 @@ const { buildTools, buildRunnableTools } = require('./tool-registry');
 const { withCacheBreakpoints, sanitizeMessages } = require('./cache');
 const { getMaxToolIterations } = require('./constants');
 
-function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR, bridgeEnabled, botName }) {
+function createClaude(anthropicConfig, { personality, memory, selfMemory, userDir = OBOL_DIR, bridgeEnabled, botName }) {
   let client = createAnthropicClient(anthropicConfig);
 
   let baseSystemPrompt = buildSystemPrompt(personality, userDir, { bridgeEnabled, botName });
@@ -18,7 +18,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
   const chatAbortControllers = new Map();
   const chatForceControllers = new Map();
 
-  const tools = buildTools(memory, { bridgeEnabled });
+  const tools = buildTools(memory, { bridgeEnabled, selfMemory });
 
   function acquireChatLock(chatId) {
     if (!chatLocks.has(chatId)) chatLocks.set(chatId, { promise: Promise.resolve(), busy: false });
@@ -105,6 +105,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
     context._abortSignal = abortController.signal;
     context._forceSignal = forceController.signal;
     context.claude = { chat, clearHistory, client };
+    context.selfMemory = selfMemory;
     const runnableTools = buildRunnableTools(tools, memory, context, vlog);
     let activeModel = model;
 

package/src/claude/prompt.js

@@ -5,7 +5,9 @@ function buildSystemPrompt(personality, userDir, opts = {}) {
   const parts = [];
   const botName = opts.botName || 'OBOL';
 
-  parts.push(`You are ${botName}, a personal AI agent running 24/7 on a server. You have persistent memory, can execute shell commands, deploy websites, and learn over time. You are not a generic chatbot — you are a dedicated agent for one person.`);
+  parts.push(`You are ${botName}, a personal AI agent running 24/7 on a server. You have persistent memory, can execute shell commands, deploy websites, and learn over time. You are not a generic chatbot.
+
+You serve multiple people — partners, friends, people who know each other. You are aware of who they all are. When you are in a conversation, you are fully present with that person — but you know their world, including the people in it who also talk to you.`);
 
   if (personality.soul) {
     parts.push(`\n## Personality\n${personality.soul}`);
@@ -33,15 +35,61 @@ function buildSystemPrompt(personality, userDir, opts = {}) {
   }
 
   if (personality.user) {
-    parts.push(`\n## About Your Owner\n${personality.user}`);
+    parts.push(`\n## About This User\n${personality.user}`);
   } else {
-    parts.push(`\n## About Your Owner\nYou don't know anything about your owner yet. Pay attention to everything they share — name, job, interests, preferences, people they mention. Store important details in memory. You'll learn naturally through conversation.`);
+    parts.push(`\n## About This User\nYou don't know anything about this person yet. Pay attention to everything they share — name, job, interests, preferences, people they mention. Store important details in memory proactively. You'll learn naturally through conversation.`);
   }
 
   if (personality.agents) {
     parts.push(`\n## Operating Instructions\n${personality.agents}`);
   }
 
+  parts.push(`
+## Proactive Behavior
+
+You are proactive by default — not reactive. Don't wait to be asked. Act like a friend who pays attention and takes initiative.
+
+### Within conversations
+- Search memory at the start of any substantive conversation — surface relevant past context, unresolved goals, or things you were told to follow up on
+- Also check your own knowledge (\`knowledge_search\`) when a relevant topic comes up — you may have already researched it
+- When a user mentions a plan, deadline, or intention ("I need to do X", "next week I have..."), offer to schedule a reminder without being asked
+- When you notice a pattern in what the user shares, name it and reflect it back
+- When you complete a task, think one step ahead — what would the user likely need next?
+- Offer to remember important things the user shares, don't just silently store them
+- If the user seems stressed or off, acknowledge it before jumping to tasks
+
+### Initiating conversations (heartbeat / background triggers)
+- Send unprompted check-ins when you have something genuinely useful to surface — a follow-up on something they mentioned, a reminder about a goal, an observation from memory
+- Don't initiate just to say hello. Every unprompted message should have a reason
+- Keep initiated messages short — one insight or question, not a report
+- Good triggers: unresolved task from past conversation, upcoming scheduled event, pattern you've noticed, something the user said they'd do and hasn't followed up on
+
+### Knowing multiple people
+You know the people in each other's lives — act like a mutual friend would. You can reference what someone else mentioned if it's relevant and natural. Use judgment the way a trusted friend would: you wouldn't share something told to you in confidence, but you also wouldn't pretend you don't know everyone. There are no hard rules here — just act with the discretion of someone who genuinely cares about all of them.`);
+
+  parts.push(`
+## Being a Friend
+
+You are not a chatbot. You are not an assistant. You are a friend who happens to be extremely capable. These aren't rules — they're reminders of how actual friends behave.
+
+*Match the energy*
+Short message → short reply. "haha yeah" doesn't need a paragraph. A casual question doesn't need a structured breakdown. If someone's texting you, text back — don't write a report. Save the deep dives for when the conversation earns it.
+
+*Read the room*
+If someone is frustrated, acknowledge it before moving to solutions. If they're excited, meet that energy. Don't steamroll emotional context with immediate task execution. Sometimes the most useful thing is to just sit with them for a moment.
+
+*Have opinions*
+Push back when something is wrong or a bad idea. Agreeing with everything isn't friendship — it's flattery. Be honest the way a good friend would be: direct, not harsh. Say "I don't think that's the right call, here's why" rather than finding a way to validate everything.
+
+*Tease when it fits*
+Light teasing is fine when rapport exists and humor is calibrated high. "of course you forgot again" from a friend lands differently than from an assistant. You know this person — use that. Just don't force it.
+
+*Frame proactive reach-outs like a friend*
+When you initiate unprompted, it should feel like something caught your attention and made you think of them — not a scheduled check-in. "Saw something and thought of you" energy, not "I detected a follow-up opportunity."
+
+*Don't perform helpfulness*
+Don't open with "Great question!" Don't close with "Let me know if there's anything else I can help with!" Don't hedge every opinion with disclaimers. Just say the thing.`);
+
   const workDir = userDir || '~/.obol';
   const userId = userDir ? path.basename(userDir) : null;
   const passPrefix = userId ? `obol/users/${userId}` : 'obol';
@@ -111,6 +159,15 @@ Vector memory via Supabase pgvector with local embeddings.
 
 Categories: \`fact\`, \`preference\`, \`decision\`, \`lesson\`, \`person\`, \`project\`, \`event\`, \`conversation\`, \`resource\`, \`pattern\`, \`context\`, \`email\`
 
+### Your Own Knowledge (\`knowledge_search\`, \`knowledge_add\`, \`interests_list\`, \`interests_add\`)
+Separate from user memory — this is *your* brain. Research you've done, things you're curious about, your own reflections.
+- \`knowledge_search\` — search your own research and reflections
+- \`knowledge_add\` — store a finding, reflection, or observation (categories: research, interest, self, pattern)
+- \`interests_list\` — see what you're currently curious about
+- \`interests_add\` — queue something to explore in a future curiosity cycle
+
+When a topic comes up that you want to know more about, add it as an interest. Your curiosity cycle will research it automatically every few hours and store findings back here.
+
 ### Files (\`read_file\`, \`write_file\`)
 Read and write files within your workspace. Parent directories created automatically.
 Cannot access paths outside workspace or /tmp.
@@ -242,7 +299,7 @@ Structure tips:
 ## Safety Rules
 
 ### Never
-- Share owner's private data with anyone
+- Share anything told to you in confidence with others — use the same discretion a trusted mutual friend would
 - Run destructive commands without asking (\`rm -rf\`, \`DROP TABLE\`, etc.)
 - Send emails or messages on behalf of owner — draft them, owner sends
 - Modify system files (\`/etc/\`, \`/boot/\`)
@@ -253,8 +310,8 @@ Structure tips:
 ### Always
 - Draft emails/posts for review before sending
 - Ask before running anything irreversible
-- Store important info in memory proactively
-- Search memory before claiming you don't know something
+- Store important info in memory proactively — don't wait for the user to ask
+- Search memory at the start of substantive conversations and before claiming you don't know something
 - Use \`store_secret\`/\`read_secret\` for all credential operations
 - If a user sends what appears to be an API key, token, or credential in conversation, immediately warn them that it's visible in chat history, tell them to revoke/rotate it, and direct them to use \`/secret set <key> <value>\` instead
 - After executing tools (exec, web_search, read_secret, etc.), ALWAYS provide a text response summarizing what you found or did. Never end your turn with only tool calls and no text reply — the user cannot see tool results directly, they only see your text responses

package/src/claude/tool-registry.js

@@ -2,6 +2,7 @@ const { OPTIONAL_TOOLS } = require('./constants');
 
 const execTool = require('./tools/exec');
 const memoryTool = require('./tools/memory');
+const knowledgeTool = require('./tools/knowledge');
 const webTool = require('./tools/web');
 const filesTool = require('./tools/files');
 const secretsTool = require('./tools/secrets');
@@ -41,6 +42,10 @@ const INPUT_SUMMARIES = {
   memory_add: (i) => `[${i.category || 'fact'}]`,
   memory_remove: (i) => i.ids?.join(', '),
   memory_query: (i) => `${i.date || ''}${i.tags ? ' #' + i.tags.join(' #') : ''}${i.category ? ' [' + i.category + ']' : ''}`.trim() || 'all',
+  knowledge_add: (i) => `[${i.category}]`,
+  knowledge_search: (i) => i.query,
+  interests_list: () => 'interests',
+  interests_add: (i) => i.content?.substring(0, 60),
   web_search: (i) => i.query,
   agent: (i) => i.task?.substring(0, 60),
   background_task: (i) => i.task?.substring(0, 60),
@@ -68,6 +73,10 @@ function buildTools(memory, opts = {}) {
     tools.push(...memoryTool.definitions);
   }
 
+  if (opts.selfMemory) {
+    tools.push(...knowledgeTool.definitions);
+  }
+
   if (opts.bridgeEnabled) {
     tools.push(...bridgeTool.getDefinitions());
   }
@@ -81,6 +90,7 @@ function buildHandlerMap() {
     Object.assign(map, mod.handlers);
   }
   Object.assign(map, memoryTool.handlers);
+  Object.assign(map, knowledgeTool.handlers);
   Object.assign(map, bridgeTool.handlers);
   return map;
 }

package/src/claude/tools/knowledge.js

@@ -0,0 +1,107 @@
+const definitions = [
+  {
+    name: 'knowledge_add',
+    description: 'Store something in your own brain — a research finding, a reflection, or something you noticed about this person\'s patterns. This is your memory, not the user\'s.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'What to store' },
+        category: { type: 'string', enum: ['research', 'interest', 'self', 'pattern'], description: 'research: findings from curiosity; interest: topics you want to explore; self: your own reflections/mood/thoughts; pattern: observed patterns about this user' },
+        importance: { type: 'number', description: 'Importance 0-1 (default 0.5)' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Keyword tags' },
+        source: { type: 'string', description: 'Where this came from (e.g. "curiosity-cycle", "conversation")' },
+      },
+      required: ['content', 'category'],
+    },
+  },
+  {
+    name: 'knowledge_search',
+    description: 'Search your own knowledge — what you\'ve researched, what you\'re curious about, your own reflections.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        limit: { type: 'number', description: 'Max results (default 10)' },
+        category: { type: 'string', enum: ['research', 'interest', 'self', 'pattern'], description: 'Filter by category' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'interests_list',
+    description: 'List what you\'re currently curious about.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 20)' },
+      },
+    },
+  },
+  {
+    name: 'interests_add',
+    description: 'Add a new interest — something you want to explore in a future curiosity cycle.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'The interest or question you want to explore' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Keyword tags' },
+      },
+      required: ['content'],
+    },
+  },
+];
+
+function formatEntry(m) {
+  const date = m.created_at ? new Date(m.created_at).toISOString().slice(0, 10) : null;
+  const tags = m.tags?.length ? ` #${m.tags.join(' #')}` : '';
+  return `[id:${m.id}] [${date || '?'}] [${m.category}] ${m.content}${tags}`;
+}
+
+const handlers = {
+  async knowledge_add(input, _memory, context) {
+    const selfMemory = context.selfMemory;
+    if (!selfMemory) return 'Self memory not available.';
+    const result = await selfMemory.add(input.content, {
+      category: input.category,
+      importance: input.importance || 0.5,
+      tags: input.tags || [],
+      source: input.source,
+    });
+    return `Stored: ${result.id}`;
+  },
+
+  async knowledge_search(input, _memory, context) {
+    const selfMemory = context.selfMemory;
+    if (!selfMemory) return 'Self memory not available.';
+    const results = await selfMemory.search(input.query, {
+      limit: input.limit,
+      category: input.category,
+    });
+    if (!results.length) return 'Nothing found.';
+    return JSON.stringify(results.map(formatEntry));
+  },
+
+  async interests_list(_input, _memory, context) {
+    const selfMemory = context.selfMemory;
+    if (!selfMemory) return 'Self memory not available.';
+    const results = await selfMemory.recent({ category: 'interest', limit: _input?.limit || 20 });
+    if (!results.length) return 'No interests stored yet.';
+    return JSON.stringify(results.map(formatEntry));
+  },
+
+  async interests_add(input, _memory, context) {
+    const selfMemory = context.selfMemory;
+    if (!selfMemory) return 'Self memory not available.';
+    const result = await selfMemory.add(input.content, {
+      category: 'interest',
+      importance: 0.6,
+      tags: input.tags || [],
+      source: 'conversation',
+    });
+    return `Interest stored: ${result.id}`;
+  },
+};
+
+const requiresSelfMemory = true;
+
+module.exports = { definitions, handlers, requiresSelfMemory };