obol-ai 0.3.14 → 0.3.16

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.16
+- Merge pull request #6 from jestersimpps/fix/status-instant-tool-labels
+- fix: replace async haiku status labels with instant sync formatToolCall
+
+## 0.3.15
+- replace impulse with news system, exact datetime for analysis follow-ups
+- rewrite impulse prompt to sound like a friend, not an assistant
+
 ## 0.3.13
 - strip citations from history to fix 400 replay errors
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "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

@@ -1,3 +1,5 @@
+const { resolveDelay } = require('./utils/timing');
+
 const ANALYSIS_WINDOW_MS = 3 * 60 * 60 * 1000;
 const MAX_MESSAGE_CHARS = 1000;
 const MAX_TRANSCRIPT_CHARS = 40000;
@@ -113,10 +115,10 @@ async function structureReport(client, report, scheduler, patterns, chatId, time
             type: 'object',
             properties: {
               description: { type: 'string' },
-              delay: { type: 'string', description: '"2h", "1d", "3d", or "1w"' },
+              due_at: { type: 'string', description: 'ISO 8601 date or datetime in the user\'s local time, e.g. "2024-03-15" or "2024-03-15T20:00"' },
               context: { type: 'string', description: 'Brief context for the follow-up message' },
             },
-            required: ['description', 'delay', 'context'],
+            required: ['description', 'due_at', 'context'],
           },
         },
         patterns: {
@@ -139,11 +141,13 @@ async function structureReport(client, report, scheduler, patterns, chatId, time
   }];
 
   try {
+    const localTime = new Date().toLocaleString('en-US', { timeZone: timezone, dateStyle: 'full', timeStyle: 'short' });
     const patternGuidance = `Extract behavioral patterns about this user from the report. Each pattern must be a factual observation about the user's behavior — not notes about your analysis process. If you see the same pattern in the existing list, reuse its exact key and update the summary/confidence. Skip patterns already at confidence >0.8 unless new evidence contradicts them.`;
+    const timingGuidance = `Current local time for this user: ${localTime}. For each follow-up, pick a specific date or datetime in the user's local time based on what you know from the transcript. Use ISO 8601 format: "2024-03-15" for date-only or "2024-03-15T20:00" for exact time.`;
 
     const system = formattedPatterns
-      ? `Existing behavioral patterns for this user:\n${formattedPatterns}\n\n---\n\n${patternGuidance}`
-      : `Convert this analytical report into structured data using the save_analysis tool. ${patternGuidance}`;
+      ? `Existing behavioral patterns for this user:\n${formattedPatterns}\n\n---\n\n${patternGuidance}\n\n${timingGuidance}`
+      : `Convert this analytical report into structured data using the save_analysis tool. ${patternGuidance}\n\n${timingGuidance}`;
 
     const response = await client.messages.create({
       model: 'claude-sonnet-4-6',
@@ -160,9 +164,12 @@ async function structureReport(client, report, scheduler, patterns, chatId, time
     const followUps = toolUse.input?.follow_ups || [];
     const patternList = toolUse.input?.patterns || [];
 
+    const timingPattern = patterns ? await patterns.get('timing.active_hours').catch(() => null) : null;
+    const timingData = timingPattern?.data || null;
+
     for (const fu of followUps) {
-      if (!fu.description || !fu.delay) continue;
-      const dueAt = resolveDelay(fu.delay);
+      if (!fu.description || !fu.due_at) continue;
+      const dueAt = resolveDelay(fu.due_at, timezone, timingData);
       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)
@@ -184,12 +191,4 @@ async function structureReport(client, report, scheduler, patterns, chatId, time
   }
 }
 
-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 };
+module.exports = { runAnalysis, buildTranscript };

package/src/claude/constants.js

@@ -35,6 +35,13 @@ const OPTIONAL_TOOLS = {
     config: {},
     defaultEnabled: true,
   },
+  proactive_news: {
+    label: 'Proactive News',
+    tools: [],
+    config: {
+      topics: { label: 'Topics', default: [] },
+    },
+  },
 };
 
 const BLOCKED_EXEC_PATTERNS = [

package/src/curiosity/dispatch.js

@@ -1,14 +1,9 @@
+const { resolveDelay } = require('../utils/timing');
+
 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;
 

package/src/curiosity/humor.js

@@ -1,14 +1,9 @@
+const { resolveDelay } = require('../utils/timing');
+
 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;
 
@@ -154,4 +149,4 @@ async function handleTool(name, input, selfMemory, userMap) {
   return 'Unknown tool';
 }
 
-module.exports = { runCuriosityHumor, resolveDelay, handleTool };
+module.exports = { runCuriosityHumor, handleTool };

package/src/curiosity/news.js

@@ -0,0 +1,125 @@
+const NEWS_MODEL = 'claude-sonnet-4-6';
+const MAX_ITERATIONS = 12;
+const CONFIDENCE_THRESHOLD = 0.6;
+const MAX_MESSAGES = 3;
+
+async function runProactiveNews(client, topics, memory, personality, timezone) {
+  const log = process.env.OBOL_VERBOSE ? (msg) => console.log(`[news] ${msg}`) : () => {};
+  const composed = [];
+
+  const localTime = new Date().toLocaleString('en-US', {
+    timeZone: timezone || 'UTC',
+    weekday: 'long',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true,
+  });
+
+  const systemParts = [
+    `You're looking up news for a friend. Not a user, not a subscriber — a friend you actually know.`,
+    `Their topics of interest: ${topics.join(', ')}`,
+    `Local time: ${localTime} (${timezone || 'UTC'})`,
+    ``,
+    `Search the web for recent news on their topics. Then check your memory of them to find personal connections — things they've mentioned, projects they're working on, opinions they've shared.`,
+    ``,
+    `Rules:`,
+    `- Max ${MAX_MESSAGES} messages. Quality over quantity — send 0 if nothing is worth sharing`,
+    `- Only compose a message if you found something genuinely interesting AND can connect it to something you know about them`,
+    `- Friend-style, not newsletter. No bullet points, no "here's your daily digest"`,
+    `- Short and punchy. Like texting a friend a link with a one-liner`,
+    `- If you find nothing worth sharing, that's fine. Don't force it`,
+  ];
+
+  if (personality?.soul) systemParts.push(`\nYour personality:\n${personality.soul}`);
+  if (personality?.user) systemParts.push(`\nWhat you know about them:\n${personality.user}`);
+
+  const tools = [
+    { type: 'web_search_20250305', name: 'web_search' },
+    {
+      name: 'search_user_memory',
+      description: 'Search your memory of this person — their interests, projects, opinions, life events',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'What to search for in your memory of them' },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'compose_news_message',
+      description: 'Compose a message to send to your friend about something you found',
+      input_schema: {
+        type: 'object',
+        properties: {
+          message: { type: 'string', description: 'The message to send — casual, friend-style' },
+          confidence: { type: 'number', description: 'How confident this is worth sending (0-1). Be honest — only high-confidence messages get sent' },
+          topic: { type: 'string', description: 'Which topic this relates to' },
+        },
+        required: ['message', 'confidence', 'topic'],
+      },
+    },
+  ];
+
+  const messages = [{ role: 'user', content: 'Check the news and see if anything is worth sharing.' }];
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    log(`Iteration ${i + 1}/${MAX_ITERATIONS}...`);
+
+    const response = await client.messages.create({
+      model: NEWS_MODEL,
+      max_tokens: 2000,
+      tools,
+      system: systemParts.join('\n'),
+      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;
+
+      if (block.name === 'search_user_memory') {
+        log(`  Memory search: "${block.input.query}"`);
+        try {
+          const results = memory
+            ? await memory.search(block.input.query, { limit: 5, threshold: 0.3 })
+            : [];
+          const text = results.length
+            ? results.map(m => `- ${m.content}`).join('\n')
+            : '(nothing found)';
+          toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: text });
+        } catch (e) {
+          toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Search failed: ${e.message}` });
+        }
+      } else if (block.name === 'compose_news_message') {
+        const { message, confidence, topic } = block.input;
+        log(`  Compose [${topic}] confidence=${confidence}: ${message.substring(0, 100)}`);
+
+        if (confidence >= CONFIDENCE_THRESHOLD && composed.length < MAX_MESSAGES) {
+          composed.push(message);
+          toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: 'Message queued for delivery' });
+        } else if (composed.length >= MAX_MESSAGES) {
+          toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Already have ${MAX_MESSAGES} messages queued. Done.` });
+        } else {
+          toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Confidence too low (${confidence} < ${CONFIDENCE_THRESHOLD}). Skip this one.` });
+        }
+      }
+    }
+
+    if (toolResults.length > 0) {
+      messages.push({ role: 'user', content: toolResults });
+    }
+
+    if (composed.length >= MAX_MESSAGES) break;
+  }
+
+  log(`Composed ${composed.length} messages`);
+  return composed;
+}
+
+module.exports = { runProactiveNews };

package/src/runtime/heartbeat.js

@@ -7,15 +7,16 @@ const { runAnalysis } = require('../analysis');
 const { runCuriosity } = require('../curiosity');
 const { runCuriosityDispatch } = require('../curiosity/dispatch');
 const { runCuriosityHumor } = require('../curiosity/humor');
-const { maybePeriodicImpulse } = require('../curiosity/impulse');
+const { runProactiveNews } = require('../curiosity/news');
 const { createSelfMemory } = require('../memory/self');
 
 
 const ANALYSIS_HOURS = new Set([4, 7, 10, 13, 16, 19, 22]);
 const CURIOSITY_HOURS = new Set([1, 7, 13, 19]);
-const IMPULSE_HOURS = new Set([4, 10, 16, 22]);
+const NEWS_HOURS = new Set([8, 18]);
 
 const _evolutionRunning = new Set();
+const _newsRunning = new Set();
 let _curiosityRunning = false;
 
 function getLocalHour(timezone) {
@@ -150,6 +151,44 @@ async function runAnalysisForUser(bot, config, userId) {
   }
 }
 
+async function runNewsForUser(bot, config, userId) {
+  if (_newsRunning.has(userId)) return;
+
+  const tenant = await getTenant(userId, config);
+  const pref = tenant.toolPrefs?.get('proactive_news');
+  if (!pref?.enabled) return;
+
+  const topics = pref.config?.topics || [];
+  if (topics.length === 0) return;
+
+  _newsRunning.add(userId);
+  console.log(`[news] Starting proactive news for user ${userId}, topics: ${topics.join(', ')}`);
+
+  try {
+    const Anthropic = require('@anthropic-ai/sdk');
+    const client = new Anthropic({ apiKey: config.anthropic.apiKey });
+    const timezone = getUserTimezone(config, userId);
+
+    const messages = await runProactiveNews(client, topics, tenant.memory, tenant.personality, timezone);
+
+    for (let i = 0; i < messages.length; i++) {
+      if (i > 0) {
+        const delay = 30_000 + Math.random() * 120_000;
+        await new Promise(r => setTimeout(r, delay));
+      }
+      await bot.api.sendMessage(userId, messages[i]).catch(() =>
+        bot.api.sendMessage(userId, messages[i], { parse_mode: undefined }).catch(() => {})
+      );
+    }
+
+    console.log(`[news] Sent ${messages.length} messages to user ${userId}`);
+  } catch (e) {
+    console.error(`[news] Failed for user ${userId}:`, e.message);
+  } finally {
+    _newsRunning.delete(userId);
+  }
+}
+
 function makeFakeCtx(bot, chatId) {
   return {
     chat: { id: chatId },
@@ -237,17 +276,18 @@ function setupHeartbeat(bot, config) {
     });
     console.log(`  ✅ Curiosity cron running (every 6h ${config.timezone || 'UTC'})`);
 
+
     cron.schedule('* * * * *', async () => {
       for (const userId of allowedUsers) {
         const tz = getUserTimezone(config, userId);
         const { hour, minute } = getLocalHour(tz);
-        if (!IMPULSE_HOURS.has(hour) || minute !== 0) continue;
-        maybePeriodicImpulse(bot, config, userId).catch(e =>
-          console.error(`[impulse] Periodic error for user ${userId}:`, e.message)
+        if (!NEWS_HOURS.has(hour) || minute !== 0) continue;
+        runNewsForUser(bot, config, userId).catch(e =>
+          console.error(`[news] Unhandled error for user ${userId}:`, e.message)
         );
       }
     });
-    console.log('  ✅ Impulse cron running (every 6h per-user timezone)');
+    console.log('  ✅ News cron running (8am + 6pm per-user timezone)');
   }
 
   console.log('  ✅ Heartbeat running (every 1min)');

package/src/status.js

@@ -1,5 +1,4 @@
 const TERM_WIDTH = 25;
-const _toolDescriptionCache = new Map();
 
 function buildStatusHtml({ route, elapsed, toolStatus, title = 'OBOL' }) {
   const pad = Math.max(0, TERM_WIDTH - title.length - 3);
@@ -28,25 +27,10 @@ function buildStatusHtml({ route, elapsed, toolStatus, title = 'OBOL' }) {
   return `<pre>${lines.join('\n')}</pre>`;
 }
 
-function describeToolCall(client, toolName, inputSummary) {
-  const key = `${toolName}:${inputSummary}`;
-  const cached = _toolDescriptionCache.get(key);
-  if (cached) return Promise.resolve(cached);
-
-  return client.messages.create({
-    model: 'claude-haiku-4-5',
-    max_tokens: 30,
-    system: 'Describe this tool call in 3-8 words from the user\'s perspective. Present participle. No quotes, period, or emoji.',
-    messages: [{ role: 'user', content: `${toolName}: ${inputSummary}` }],
-  }).then(r => {
-    const desc = r.content[0]?.text?.trim() || null;
-    if (desc) _toolDescriptionCache.set(key, desc);
-    if (_toolDescriptionCache.size > 200) {
-      const first = _toolDescriptionCache.keys().next().value;
-      _toolDescriptionCache.delete(first);
-    }
-    return desc;
-  }).catch(() => null);
+function formatToolCall(toolName, inputSummary) {
+  if (!inputSummary) return toolName;
+  const truncated = inputSummary.length > 40 ? inputSummary.slice(0, 37) + '...' : inputSummary;
+  return `${toolName} "${truncated}"`;
 }
 
-module.exports = { buildStatusHtml, describeToolCall, TERM_WIDTH };
+module.exports = { buildStatusHtml, formatToolCall, TERM_WIDTH };

package/src/telegram/bot.js

@@ -101,6 +101,7 @@ function createBot(telegramConfig, config) {
     { command: 'verbose', description: 'Toggle verbose mode on/off' },
     { command: 'toolimit', description: 'View or set max tool iterations per message' },
     { command: 'tools', description: 'Toggle optional tools on/off' },
+    { command: 'topics', description: 'Edit news topics' },
     { command: 'stop', description: 'Stop the current request' },
     { command: 'upgrade', description: 'Check for updates and upgrade' },
     { command: 'help', description: 'Show available commands' },
@@ -113,6 +114,12 @@ function createBot(telegramConfig, config) {
   secretsCommands.register(bot, config);
   toolsCommands.register(bot, config);
 
+  bot.command('topics', async (ctx) => {
+    if (!ctx.from) return;
+    const { sendTopicEditor } = require('./topics');
+    await sendTopicEditor(ctx, config);
+  });
+
   const deps = { config, allowedUsers, bot, createAsk };
   registerTextHandler(bot, deps);
   registerMediaHandler(bot, telegramConfig, deps);

package/src/telegram/commands/tools.js

@@ -2,6 +2,7 @@ const { InlineKeyboard } = require('grammy');
 const { getTenant } = require('../../tenant');
 const { OPTIONAL_TOOLS } = require('../../claude');
 const { clearVoiceFlow, sendVoiceLanguagePicker } = require('../voice');
+const { clearTopicFlow, sendTopicEditor } = require('../topics');
 const { TERM_SEP } = require('../constants');
 
 function isEnabled(pref, feature) {
@@ -34,6 +35,7 @@ function register(bot, config) {
   bot.command('tools', async (ctx) => {
     if (!ctx.from) return;
     await clearVoiceFlow(ctx.from.id, bot);
+    await clearTopicFlow(ctx.from.id, bot);
     const tenant = await getTenant(ctx.from.id, config);
     await tenant.reloadToolPrefs();
     const text = buildToolsMessage(tenant.toolPrefs);
@@ -47,6 +49,7 @@ async function handleToolCallback(ctx, featureKey, answer, { getTenant: gt, conf
   if (!ctx.from) return answer();
 
   await clearVoiceFlow(ctx.from.id, bot);
+  await clearTopicFlow(ctx.from.id, bot);
 
   const tenant = await gt(ctx.from.id, cfg);
   if (!tenant.toolPrefsApi) return answer({ text: 'Not available' });
@@ -64,6 +67,10 @@ async function handleToolCallback(ctx, featureKey, answer, { getTenant: gt, conf
   if (newEnabled && Object.keys(feature.config).length > 0 && feature.config.voice) {
     sendVoiceLanguagePicker(ctx);
   }
+
+  if (newEnabled && featureKey === 'proactive_news') {
+    sendTopicEditor(ctx, cfg);
+  }
 }
 
 module.exports = { register, handleToolCallback, buildToolsMessage, buildToolsKeyboard };

package/src/telegram/handlers/callbacks.js

@@ -1,5 +1,6 @@
 const { handleToolCallback } = require('../commands/tools');
 const { handleVoiceCallback } = require('../voice');
+const { handleTopicCallback } = require('../topics');
 
 function registerCallbackHandler(bot, { config, pendingAsks, getTenant }) {
   bot.on('callback_query:data', async (ctx) => {
@@ -37,6 +38,11 @@ function registerCallbackHandler(bot, { config, pendingAsks, getTenant }) {
       return;
     }
 
+    if (data.startsWith('topics:')) {
+      await handleTopicCallback(ctx, data, answer, { getTenant, config, bot });
+      return;
+    }
+
     if (data.startsWith('bridge:reply:')) {
       const targetUserId = parseInt(data.split(':')[2]);
       const reactingUserId = ctx.from.id;

package/src/telegram/handlers/media.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const { getTenant } = require('../../tenant');
-const { buildStatusHtml, describeToolCall } = require('../../status');
+const { buildStatusHtml, formatToolCall } = require('../../status');
 const media = require('../../media');
 const { sendHtml, startTyping, splitMessage } = require('../utils');
 const { MAX_MEDIA_SIZE, MEDIA_GROUP_DELAY_MS } = require('../constants');
@@ -80,11 +80,9 @@ async function processMediaItems(ctx, items, { config, allowedUsers, bot, create
       if (update.model) ri.model = update.model;
     };
     mediaChatCtx._onToolStart = (toolName, inputSummary) => {
-      status.setStatusText('Processing');
-      describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
-        if (desc) status.setStatusText(desc);
-      });
+      status.setStatusText(formatToolCall(toolName, inputSummary));
       status.start();
+      status.pushUpdate();
     };
     mediaChatCtx._onLockTimeout = () => {
       status.clear();

package/src/telegram/handlers/special.js

@@ -1,5 +1,5 @@
 const { getTenant } = require('../../tenant');
-const { describeToolCall } = require('../../status');
+const { formatToolCall } = require('../../status');
 const { sendHtml, startTyping, splitMessage } = require('../utils');
 const { createChatContext, createStatusTracker } = require('./text');
 
@@ -92,11 +92,9 @@ async function processSpecial(ctx, prompt, deps) {
       if (update.model) ri.model = update.model;
     };
     chatCtx._onToolStart = (toolName, inputSummary) => {
-      status.setStatusText('Processing');
-      describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
-        if (desc) status.setStatusText(desc);
-      });
+      status.setStatusText(formatToolCall(toolName, inputSummary));
       status.start();
+      status.pushUpdate();
     };
 
     const { text: response, usage, model } = await tenant.claude.chat(prompt, chatCtx);

package/src/telegram/handlers/text.js

@@ -1,6 +1,6 @@
 const { InlineKeyboard } = require('grammy');
 const { getTenant } = require('../../tenant');
-const { buildStatusHtml, describeToolCall } = require('../../status');
+const { buildStatusHtml, formatToolCall } = require('../../status');
 const { sendHtml, startTyping, splitMessage } = require('../utils');
 const { TEXT_BUFFER_GAP_MS, TEXT_BUFFER_MAX_PARTS, TEXT_BUFFER_MAX_CHARS, TEXT_BUFFER_THRESHOLD } = require('../constants');
 
@@ -133,6 +133,12 @@ function createStatusTracker(ctx, botName) {
       const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: 'Formatting output', title });
       ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
     },
+    pushUpdate() {
+      if (!statusMsgId) return;
+      const elapsed = statusStart ? Math.round((Date.now() - statusStart) / 1000) : 0;
+      const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: statusText, title });
+      ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML', reply_markup: stopBtn }).catch(() => {});
+    },
     deleteMsg() {
       if (statusMsgId) ctx.api.deleteMessage(ctx.chat.id, statusMsgId).catch(() => {});
     },
@@ -185,11 +191,9 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
       if (update.model) ri.model = update.model;
     };
     chatContext._onToolStart = (toolName, inputSummary) => {
-      status.setStatusText('Processing');
-      describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
-        if (desc) status.setStatusText(desc);
-      });
+      status.setStatusText(formatToolCall(toolName, inputSummary));
       status.start();
+      status.pushUpdate();
     };
     chatContext._onLockTimeout = () => {
       status.clear();
@@ -211,9 +215,6 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
 
     tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
 
-    const { maybeImpulse } = require('../../curiosity/impulse');
-    maybeImpulse(bot, config, tenant, ctx.chat.id, chatMessage, response).catch(() => {});
-
     stopTyping();
 
     if (response.length > 4096) {
@@ -294,6 +295,12 @@ function registerTextHandler(bot, { config, allowedUsers, createAsk }) {
       return;
     }
 
+    const { isPendingTopicInput, handleTopicText } = require('../topics');
+    if (isPendingTopicInput(userId)) {
+      await handleTopicText(ctx, userMessage, { getTenant, config, bot });
+      return;
+    }
+
     const rateResult = bot._rateLimiter.check(userId);
     if (rateResult === 'cooldown' || rateResult === 'skip') return;
     if (rateResult === 'spam') {

package/src/telegram/topics.js

@@ -0,0 +1,170 @@
+const { InlineKeyboard } = require('grammy');
+const { sendHtml } = require('./utils');
+
+const MAX_TOPICS = 20;
+const PENDING_TTL_MS = 60_000;
+
+/** @type {Map<number, { chatId: number, messageId: number }[]>} */
+const topicFlowMessages = new Map();
+
+/** @type {Map<number, { timer: ReturnType<typeof setTimeout> }>} */
+const pendingTopicInput = new Map();
+
+function trackMsg(userId, chatId, messageId) {
+  if (!topicFlowMessages.has(userId)) topicFlowMessages.set(userId, []);
+  topicFlowMessages.get(userId).push({ chatId, messageId });
+}
+
+async function clearTopicFlow(userId, bot) {
+  const msgs = topicFlowMessages.get(userId);
+  if (!msgs) return;
+  topicFlowMessages.delete(userId);
+  cancelPending(userId);
+  for (const { chatId, messageId } of msgs) {
+    bot.api.deleteMessage(chatId, messageId).catch(() => {});
+  }
+}
+
+function cancelPending(userId) {
+  const pending = pendingTopicInput.get(userId);
+  if (pending) {
+    clearTimeout(pending.timer);
+    pendingTopicInput.delete(userId);
+  }
+}
+
+function isPendingTopicInput(userId) {
+  return pendingTopicInput.has(userId);
+}
+
+function normalizeTopics(raw) {
+  return [...new Set(
+    raw
+      .split(',')
+      .map(t => t.trim().toLowerCase())
+      .filter(t => t.length > 0)
+  )].slice(0, MAX_TOPICS);
+}
+
+function buildEditorKeyboard(topics) {
+  const kb = new InlineKeyboard();
+  for (let i = 0; i < topics.length; i++) {
+    kb.text(`✕ ${topics[i]}`, `topics:remove:${i}`);
+    if ((i + 1) % 2 === 0) kb.row();
+  }
+  if (topics.length % 2 !== 0) kb.row();
+  kb.text('＋ Add topics', 'topics:add').row();
+  kb.text('✓ Done', 'topics:done');
+  return kb;
+}
+
+function buildEditorText(topics) {
+  if (topics.length === 0) return 'No topics yet. Add some to get started.';
+  return `Your news topics (${topics.length}/${MAX_TOPICS}):`;
+}
+
+async function sendTopicEditor(ctx, config) {
+  if (!ctx.from) return;
+  const userId = ctx.from.id;
+  const { getTenant } = require('../tenant');
+  const tenant = await getTenant(userId, config);
+  const pref = tenant.toolPrefs.get('proactive_news');
+  const topics = pref?.config?.topics || [];
+
+  const text = buildEditorText(topics);
+  const kb = buildEditorKeyboard(topics);
+  const msg = await ctx.reply(text, { reply_markup: kb });
+  trackMsg(userId, msg.chat.id, msg.message_id);
+}
+
+async function handleTopicCallback(ctx, data, answer, { getTenant, config, bot }) {
+  if (!ctx.from) return answer();
+  const userId = ctx.from.id;
+  const parts = data.split(':');
+  const action = parts[1];
+
+  if (action === 'remove') {
+    const idx = parseInt(parts[2]);
+    const tenant = await getTenant(userId, config);
+    const pref = tenant.toolPrefs.get('proactive_news');
+    const topics = [...(pref?.config?.topics || [])];
+    const removed = topics.splice(idx, 1)[0];
+    await answer({ text: removed ? `Removed "${removed}"` : 'Already removed' });
+
+    if (tenant.toolPrefsApi) {
+      const newConfig = { ...(pref?.config || {}), topics };
+      await tenant.toolPrefsApi.set('proactive_news', true, newConfig);
+      await tenant.reloadToolPrefs();
+    }
+
+    const text = buildEditorText(topics);
+    const kb = buildEditorKeyboard(topics);
+    ctx.editMessageText(text, { reply_markup: kb }).catch(() => {});
+    return;
+  }
+
+  if (action === 'add') {
+    await answer();
+    const pref = (await getTenant(userId, config)).toolPrefs.get('proactive_news');
+    const current = pref?.config?.topics || [];
+    if (current.length >= MAX_TOPICS) {
+      const msg = await ctx.reply(`Max ${MAX_TOPICS} topics. Remove some first.`);
+      trackMsg(userId, msg.chat.id, msg.message_id);
+      return;
+    }
+
+    cancelPending(userId);
+    const timer = setTimeout(() => pendingTopicInput.delete(userId), PENDING_TTL_MS);
+    pendingTopicInput.set(userId, { timer });
+
+    const msg = await ctx.reply('Type your topics, separated by commas:');
+    trackMsg(userId, msg.chat.id, msg.message_id);
+    return;
+  }
+
+  if (action === 'done') {
+    await answer({ text: 'Topics saved' });
+    await clearTopicFlow(userId, bot);
+    return;
+  }
+
+  return answer();
+}
+
+async function handleTopicText(ctx, text, { getTenant, config, bot }) {
+  const userId = ctx.from.id;
+  cancelPending(userId);
+
+  const tenant = await getTenant(userId, config);
+  const pref = tenant.toolPrefs.get('proactive_news');
+  const existing = pref?.config?.topics || [];
+  const incoming = normalizeTopics(text);
+
+  if (incoming.length === 0) {
+    const msg = await ctx.reply('No valid topics found. Try again with comma-separated topics.');
+    trackMsg(userId, msg.chat.id, msg.message_id);
+    return;
+  }
+
+  const merged = [...new Set([...existing, ...incoming])].slice(0, MAX_TOPICS);
+
+  if (tenant.toolPrefsApi) {
+    const newConfig = { ...(pref?.config || {}), topics: merged };
+    await tenant.toolPrefsApi.set('proactive_news', true, newConfig);
+    await tenant.reloadToolPrefs();
+  }
+
+  const added = merged.length - existing.length;
+  const editorText = buildEditorText(merged);
+  const kb = buildEditorKeyboard(merged);
+  const msg = await ctx.reply(`Added ${added} topic${added !== 1 ? 's' : ''}.\n\n${editorText}`, { reply_markup: kb });
+  trackMsg(userId, msg.chat.id, msg.message_id);
+}
+
+module.exports = {
+  clearTopicFlow,
+  sendTopicEditor,
+  handleTopicCallback,
+  isPendingTopicInput,
+  handleTopicText,
+};

package/src/utils/timing.js

@@ -0,0 +1,122 @@
+const DEFAULT_PEAK_HOUR = 20;
+
+function resolveDelay(input, timezone, timingData) {
+  const dt = parseDateTime(input, timezone, timingData);
+  if (dt) return dt;
+
+  const legacy = parseLegacy(input);
+  if (legacy) return legacy;
+
+  const peakHour = extractPeakHour(timingData);
+  const now = localNow(timezone);
+  return targetPeak(now, peakHour, 1, timezone);
+}
+
+function parseDateTime(input, timezone, timingData) {
+  const dtMatch = input.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/);
+  if (dtMatch) {
+    const [, y, m, d, h, min] = dtMatch.map(Number);
+    return localToUTC(y, m, d, h, min, timezone).toISOString();
+  }
+
+  const dateMatch = input.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateMatch) {
+    const [, y, m, d] = dateMatch.map(Number);
+    const peak = extractPeakHour(timingData);
+    return localToUTC(y, m, d, peak, 0, timezone).toISOString();
+  }
+
+  return null;
+}
+
+function localToUTC(year, month, day, hour, minute, timezone) {
+  const d = new Date(Date.UTC(year, month - 1, day, hour, minute, 0, 0));
+  try {
+    for (let i = 0; i < 3; i++) {
+      const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', hour12: false,
+      }).formatToParts(d);
+      const get = (type) => parseInt(parts.find(p => p.type === type).value);
+      const diffMin = (hour * 60 + minute) - (get('hour') * 60 + get('minute'));
+      const diffDay = day - get('day');
+      const totalDiff = diffDay * 1440 + diffMin;
+      if (totalDiff === 0) break;
+      d.setTime(d.getTime() + totalDiff * 60000);
+    }
+    return d;
+  } catch {
+    return d;
+  }
+}
+
+function parseLegacy(delay) {
+  const units = { h: 3600000, d: 86400000, w: 604800000 };
+  const match = delay.match(/^(\d+)([hdw])$/);
+  if (!match) return null;
+  return new Date(Date.now() + parseInt(match[1]) * units[match[2]]).toISOString();
+}
+
+function extractPeakHour(timingData) {
+  if (!timingData?.peak_hours?.length) return DEFAULT_PEAK_HOUR;
+  const first = timingData.peak_hours[0];
+  const hourMatch = first.match(/^(\d{1,2})/);
+  if (!hourMatch) return DEFAULT_PEAK_HOUR;
+  const hour = parseInt(hourMatch[1]);
+  return hour >= 0 && hour <= 23 ? hour : DEFAULT_PEAK_HOUR;
+}
+
+function localNow(timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone,
+      year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit', hour12: false,
+    }).formatToParts(new Date());
+    const get = (type) => parseInt(parts.find(p => p.type === type).value);
+    return { year: get('year'), month: get('month'), day: get('day'), hour: get('hour'), minute: get('minute') };
+  } catch {
+    const d = new Date();
+    return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate(), hour: d.getUTCHours(), minute: d.getUTCMinutes() };
+  }
+}
+
+function targetPeak(now, peakHour, daysAhead, timezone) {
+  const base = toUTCDate(now, timezone);
+  base.setUTCDate(base.getUTCDate() + daysAhead);
+  const target = setLocalHour(base, peakHour, timezone);
+  return target.toISOString();
+}
+
+function toUTCDate(local, timezone) {
+  const dateStr = `${local.year}-${String(local.month).padStart(2, '0')}-${String(local.day).padStart(2, '0')}T12:00:00`;
+  const utc = new Date(dateStr + 'Z');
+  const probe = new Date(utc);
+  const localAtProbe = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit',
+  }).formatToParts(probe);
+  const probeDay = parseInt(localAtProbe.find(p => p.type === 'day').value);
+  if (probeDay !== local.day) {
+    const offset = probeDay > local.day ? -1 : 1;
+    utc.setUTCDate(utc.getUTCDate() + offset);
+  }
+  return utc;
+}
+
+function setLocalHour(utcDate, targetHour, timezone) {
+  const d = new Date(utcDate);
+  d.setUTCHours(targetHour, 0, 0, 0);
+  for (let i = 0; i < 3; i++) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone, hour: '2-digit', hour12: false,
+    }).formatToParts(d);
+    const localHour = parseInt(parts.find(p => p.type === 'hour').value);
+    if (localHour === targetHour) return d;
+    const diff = targetHour - localHour;
+    d.setUTCHours(d.getUTCHours() + diff);
+  }
+  return d;
+}
+
+module.exports = { resolveDelay, extractPeakHour };

package/src/curiosity/impulse.js

@@ -1,157 +0,0 @@
-const Anthropic = require('@anthropic-ai/sdk');
-const { createSelfMemory } = require('../memory/self');
-const { getTenant } = require('../tenant');
-const { getUserTimezone } = require('../config');
-
-const IMPULSE_MODEL = 'claude-haiku-4-5-20251001';
-const COOLDOWN_MS = 24 * 60 * 60 * 1000;
-const MIN_DELAY_MS = 30_000;
-const MAX_DELAY_MS = 300_000;
-
-/** @type {Map<number, number>} */
-const _cooldowns = new Map();
-
-/** @type {ReturnType<typeof createSelfMemory> | null} */
-let _globalSelfMemory = null;
-
-async function getGlobalSelfMemory(supabaseConfig) {
-  if (!_globalSelfMemory) {
-    _globalSelfMemory = await createSelfMemory(supabaseConfig, 0);
-  }
-  return _globalSelfMemory;
-}
-
-function isOnCooldown(userId) {
-  const last = _cooldowns.get(userId);
-  return last && (Date.now() - last) < COOLDOWN_MS;
-}
-
-function getTimeContext(timezone) {
-  return new Date().toLocaleString('en-US', {
-    timeZone: timezone || 'UTC',
-    weekday: 'long',
-    hour: '2-digit',
-    minute: '2-digit',
-    hour12: true,
-  });
-}
-
-async function gatherContext(tenant, supabaseConfig, opts = {}) {
-  const parts = [];
-
-  parts.push(`Time: ${getTimeContext(opts.timezone)} (${opts.timezone || 'UTC'})`);
-
-  const [patterns, userMemories, selfFacts, globalFindings] = await Promise.all([
-    tenant.patterns?.format().catch(() => null),
-    tenant.memory?.recent({ limit: 5 }).catch(() => []),
-    tenant.selfMemory?.recent({ limit: 3 }).catch(() => []),
-    supabaseConfig ? getGlobalSelfMemory(supabaseConfig).then(sm => sm.recent({ limit: 5 })).catch(() => []) : [],
-  ]);
-
-  if (patterns) parts.push(`Patterns:\n${patterns}`);
-  if (userMemories?.length) parts.push(`What you know about them:\n${userMemories.map(m => `- ${m.content}`).join('\n')}`);
-  if (selfFacts?.length) parts.push(`Your notes about this relationship:\n${selfFacts.map(m => `- ${m.content}`).join('\n')}`);
-  if (globalFindings?.length) parts.push(`Your recent explorations:\n${globalFindings.map(m => `- ${m.content}`).join('\n')}`);
-
-  if (!opts.periodic && opts.lastUserMsg) {
-    const userSnip = opts.lastUserMsg.substring(0, 500);
-    const assistantSnip = opts.lastAssistantMsg?.substring(0, 500) || '';
-    parts.push(`Last exchange:\nThem: ${userSnip}\nYou: ${assistantSnip}`);
-  }
-
-  return { text: parts.join('\n\n'), hasSubstance: (globalFindings?.length > 0 || userMemories?.length > 0) };
-}
-
-async function checkImpulse(client, context) {
-  const response = await client.messages.create({
-    model: IMPULSE_MODEL,
-    max_tokens: 300,
-    system: `You're texting a friend. Not a user, not a client — a friend you actually know.
-Here's what's on your mind and what you know about them.
-
-Decide if you have something genuine to say. Think about how a real friend texts:
-- Share something interesting you came across that made you think of them
-- React to something specific happening in their life ("did the boat inspection go ok?")
-- Drop a random thought or observation, the way friends do
-- Be casual, short, lowercase is fine — no corporate check-in energy
-
-Most of the time: no. Only when it would feel natural. Friends don't message on a schedule.
-Never be vague or generic. Don't say "how's the project going" or "how's work" —
-if you can't name the specific thing, you don't know enough to bring it up.
-Don't follow up on the conversation that just happened — that's not your job here.
-Never sound like an assistant. No "just checking in!" or "hope you're doing well!" —
-that's not how friends talk.`,
-    messages: [{ role: 'user', content: context }],
-    tool_choice: { type: 'tool', name: 'impulse' },
-    tools: [{
-      name: 'impulse',
-      description: 'Decide whether to send a spontaneous message',
-      input_schema: {
-        type: 'object',
-        properties: {
-          act: { type: 'boolean', description: 'true if you have something genuine to say' },
-          thought: { type: 'string', description: 'The message to send, if acting' },
-          kind: { type: 'string', enum: ['curiosity', 'checkin', 'observation'] },
-        },
-        required: ['act'],
-      },
-    }],
-  });
-
-  const toolUse = response.content.find(b => b.type === 'tool_use');
-  return toolUse?.input || { act: false };
-}
-
-function sendImpulse(bot, chatId, thought, kind, userId) {
-  const delay = MIN_DELAY_MS + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS);
-  setTimeout(() => {
-    bot.api.sendMessage(chatId, thought).catch(() =>
-      bot.api.sendMessage(chatId, thought, { parse_mode: undefined }).catch(() => {})
-    );
-    console.log(`[impulse] Sent ${kind} to user ${userId}`);
-  }, delay);
-}
-
-async function maybeImpulse(bot, config, tenant, chatId, lastUserMsg, lastAssistantMsg) {
-  const userId = tenant.userId;
-  if (isOnCooldown(userId)) return;
-  if (!config.supabase) return;
-
-  const { text: context, hasSubstance } = await gatherContext(tenant, config.supabase, {
-    lastUserMsg,
-    lastAssistantMsg,
-    timezone: getUserTimezone(config, tenant.userId),
-  });
-  if (!hasSubstance) return;
-
-  const client = new Anthropic({ apiKey: config.anthropic.apiKey });
-  const result = await checkImpulse(client, context);
-
-  if (!result.act || !result.thought) return;
-
-  _cooldowns.set(userId, Date.now());
-  sendImpulse(bot, chatId, result.thought, result.kind || 'observation', userId);
-}
-
-async function maybePeriodicImpulse(bot, config, userId) {
-  if (isOnCooldown(userId)) return;
-  if (!config.supabase) return;
-
-  const tenant = await getTenant(userId, config);
-
-  const { text: context, hasSubstance } = await gatherContext(tenant, config.supabase, {
-    periodic: true,
-    timezone: getUserTimezone(config, userId),
-  });
-  if (!hasSubstance) return;
-
-  const client = new Anthropic({ apiKey: config.anthropic.apiKey });
-  const result = await checkImpulse(client, context);
-
-  if (!result.act || !result.thought) return;
-
-  _cooldowns.set(userId, Date.now());
-  sendImpulse(bot, userId, result.thought, result.kind || 'checkin', userId);
-}
-
-module.exports = { maybeImpulse, maybePeriodicImpulse };