kernelbot 1.0.30 → 1.0.33

package/src/bot.js

@@ -53,9 +53,16 @@ class ChatQueue {
   }
 }
 
-export function startBot(config, agent, conversationManager, jobManager, automationManager) {
+export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
+  const { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge } = lifeDeps;
   const logger = getLogger();
-  const bot = new TelegramBot(config.telegram.bot_token, { polling: true });
+  const bot = new TelegramBot(config.telegram.bot_token, {
+    polling: {
+      params: {
+        allowed_updates: ['message', 'callback_query', 'message_reaction'],
+      },
+    },
+  });
   const chatQueue = new ChatQueue();
   const batchWindowMs = config.telegram.batch_window_ms || 3000;
 
@@ -87,6 +94,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     { command: 'jobs', description: 'List running and recent jobs' },
     { command: 'cancel', description: 'Cancel running job(s)' },
     { command: 'auto', description: 'Manage recurring automations' },
+    { command: 'life', description: 'Inner life engine status and control' },
+    { command: 'journal', description: 'View today\'s journal or a past date' },
+    { command: 'memories', description: 'View recent memories or search' },
+    { command: 'evolution', description: 'Self-evolution status, history, and lessons' },
     { command: 'context', description: 'Show all models, auth, and context info' },
     { command: 'clean', description: 'Clear conversation and start fresh' },
     { command: 'history', description: 'Show message count in memory' },
@@ -125,7 +136,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
               });
               return edited.message_id;
             } catch {
-              return opts.editMessageId;
+              // Edit failed — fall through to send new message
             }
           }
         }
@@ -1100,6 +1111,296 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── /life command ──────────────────────────────────────────────
+    if (text === '/life' || text.startsWith('/life ')) {
+      logger.info(`[Bot] /life command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/life'.length).trim();
+
+      if (!lifeEngine) {
+        await bot.sendMessage(chatId, 'Life engine is not available.');
+        return;
+      }
+
+      if (args === 'pause') {
+        lifeEngine.pause();
+        await bot.sendMessage(chatId, '⏸️ Inner life paused. Use `/life resume` to restart.', { parse_mode: 'Markdown' });
+        return;
+      }
+      if (args === 'resume') {
+        lifeEngine.resume();
+        await bot.sendMessage(chatId, '▶️ Inner life resumed!');
+        return;
+      }
+      if (args.startsWith('trigger')) {
+        const activityType = args.split(/\s+/)[1] || null;
+        const validTypes = ['think', 'browse', 'journal', 'create', 'self_code', 'code_review', 'reflect'];
+        if (activityType && !validTypes.includes(activityType)) {
+          await bot.sendMessage(chatId, `Unknown activity type. Available: ${validTypes.join(', ')}`);
+          return;
+        }
+        await bot.sendMessage(chatId, `⚡ Triggering ${activityType || 'random'} activity...`);
+        lifeEngine.triggerNow(activityType).catch(err => {
+          logger.error(`[Bot] Life trigger failed: ${err.message}`);
+        });
+        return;
+      }
+      if (args === 'review') {
+        if (evolutionTracker) {
+          const active = evolutionTracker.getActiveProposal();
+          const openPRs = evolutionTracker.getPRsToCheck();
+          const lines = ['*Evolution Status*', ''];
+          if (active) {
+            lines.push(`Active: \`${active.id}\` — ${active.status}`);
+            lines.push(`  ${(active.triggerContext || '').slice(0, 150)}`);
+          } else {
+            lines.push('_No active proposals._');
+          }
+          if (openPRs.length > 0) {
+            lines.push('', '*Open PRs:*');
+            for (const p of openPRs) {
+              lines.push(`  • PR #${p.prNumber}: ${p.prUrl || 'no URL'}`);
+            }
+          }
+          lines.push('', '_Use `/evolution` for full evolution status._');
+          await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        } else {
+          await bot.sendMessage(chatId, 'Evolution system not available. Use `/evolution` for details.', { parse_mode: 'Markdown' });
+        }
+        return;
+      }
+
+      // Default: show status
+      const status = lifeEngine.getStatus();
+      const lines = [
+        '🌱 *Inner Life*',
+        '',
+        `*Status:* ${status.paused ? '⏸️ Paused' : status.status === 'active' ? '🟢 Active' : '⚪ Idle'}`,
+        `*Total activities:* ${status.totalActivities}`,
+        `*Last activity:* ${status.lastActivity || 'none'} (${status.lastActivityAgo})`,
+        `*Last wake-up:* ${status.lastWakeUpAgo}`,
+        '',
+        '*Activity counts:*',
+        `  💭 Think: ${status.activityCounts.think || 0}`,
+        `  🌐 Browse: ${status.activityCounts.browse || 0}`,
+        `  📓 Journal: ${status.activityCounts.journal || 0}`,
+        `  🎨 Create: ${status.activityCounts.create || 0}`,
+        `  🔧 Self-code: ${status.activityCounts.self_code || 0}`,
+        `  🔍 Code review: ${status.activityCounts.code_review || 0}`,
+        `  🪞 Reflect: ${status.activityCounts.reflect || 0}`,
+        '',
+        '_Commands:_',
+        '`/life pause` — Pause activities',
+        '`/life resume` — Resume activities',
+        '`/life trigger [think|browse|journal|create|self_code|code_review|reflect]` — Trigger now',
+      ];
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /journal command ─────────────────────────────────────────
+    if (text === '/journal' || text.startsWith('/journal ')) {
+      logger.info(`[Bot] /journal command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!journalManager) {
+        await bot.sendMessage(chatId, 'Journal system is not available.');
+        return;
+      }
+
+      const args = text.slice('/journal'.length).trim();
+
+      if (args && /^\d{4}-\d{2}-\d{2}$/.test(args)) {
+        const entry = journalManager.getEntry(args);
+        if (!entry) {
+          await bot.sendMessage(chatId, `No journal entry for ${args}.`);
+          return;
+        }
+        const chunks = splitMessage(entry);
+        for (const chunk of chunks) {
+          try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+          catch { await bot.sendMessage(chatId, chunk); }
+        }
+        return;
+      }
+
+      if (args === 'list') {
+        const dates = journalManager.list(15);
+        if (dates.length === 0) {
+          await bot.sendMessage(chatId, 'No journal entries yet.');
+          return;
+        }
+        const lines = ['📓 *Journal Entries*', '', ...dates.map(d => `  • \`${d}\``)];
+        lines.push('', '_Use `/journal YYYY-MM-DD` to read an entry._');
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show today's journal
+      const today = journalManager.getToday();
+      if (!today) {
+        await bot.sendMessage(chatId, '📓 No journal entries today yet.\n\n_Use `/journal list` to see past entries._', { parse_mode: 'Markdown' });
+        return;
+      }
+      const chunks = splitMessage(today);
+      for (const chunk of chunks) {
+        try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+        catch { await bot.sendMessage(chatId, chunk); }
+      }
+      return;
+    }
+
+    // ── /memories command ────────────────────────────────────────
+    if (text === '/memories' || text.startsWith('/memories ')) {
+      logger.info(`[Bot] /memories command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!memoryManager) {
+        await bot.sendMessage(chatId, 'Memory system is not available.');
+        return;
+      }
+
+      const args = text.slice('/memories'.length).trim();
+
+      if (args.startsWith('about ')) {
+        const query = args.slice('about '.length).trim();
+        const results = memoryManager.searchEpisodic(query, 10);
+        if (results.length === 0) {
+          await bot.sendMessage(chatId, `No memories matching "${query}".`);
+          return;
+        }
+        const lines = [`🧠 *Memories about "${query}"*`, ''];
+        for (const m of results) {
+          const date = new Date(m.timestamp).toLocaleDateString();
+          lines.push(`• ${m.summary} _(${date}, importance: ${m.importance})_`);
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show last 10 memories
+      const recent = memoryManager.getRecentEpisodic(168, 10); // last 7 days
+      if (recent.length === 0) {
+        await bot.sendMessage(chatId, '🧠 No memories yet.');
+        return;
+      }
+      const lines = ['🧠 *Recent Memories*', ''];
+      for (const m of recent) {
+        const ago = Math.round((Date.now() - m.timestamp) / 60000);
+        const timeLabel = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
+        const icon = { interaction: '💬', discovery: '🔍', thought: '💭', creation: '🎨' }[m.type] || '•';
+        lines.push(`${icon} ${m.summary} _(${timeLabel})_`);
+      }
+      lines.push('', '_Use `/memories about <topic>` to search._');
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /evolution command ──────────────────────────────────────────
+    if (text === '/evolution' || text.startsWith('/evolution ')) {
+      logger.info(`[Bot] /evolution command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/evolution'.length).trim();
+
+      if (!evolutionTracker) {
+        await bot.sendMessage(chatId, 'Evolution system is not available.');
+        return;
+      }
+
+      if (args === 'history') {
+        const proposals = evolutionTracker.getRecentProposals(10);
+        if (proposals.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution proposals yet.');
+          return;
+        }
+        const lines = ['*Evolution History*', ''];
+        for (const p of proposals.reverse()) {
+          const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄', merged: '✅', rejected: '❌', failed: '💥' }[p.status] || '•';
+          const age = Math.round((Date.now() - p.createdAt) / 3600_000);
+          const ageLabel = age < 24 ? `${age}h ago` : `${Math.round(age / 24)}d ago`;
+          lines.push(`${statusIcon} \`${p.id}\` — ${p.status} (${ageLabel})`);
+          lines.push(`  ${(p.triggerContext || '').slice(0, 100)}`);
+          if (p.prUrl) lines.push(`  PR: ${p.prUrl}`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'lessons') {
+        const lessons = evolutionTracker.getRecentLessons(15);
+        if (lessons.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution lessons learned yet.');
+          return;
+        }
+        const lines = ['*Evolution Lessons*', ''];
+        for (const l of lessons.reverse()) {
+          lines.push(`• [${l.category}] ${l.lesson}`);
+          if (l.fromProposal) lines.push(`  _from ${l.fromProposal}_`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'trigger') {
+        if (!lifeEngine) {
+          await bot.sendMessage(chatId, 'Life engine is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '⚡ Triggering evolution cycle...');
+        lifeEngine.triggerNow('self_code').catch(err => {
+          logger.error(`[Bot] Evolution trigger failed: ${err.message}`);
+        });
+        return;
+      }
+
+      if (args === 'scan') {
+        if (!codebaseKnowledge) {
+          await bot.sendMessage(chatId, 'Codebase knowledge is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '🔍 Scanning codebase...');
+        codebaseKnowledge.scanChanged().then(count => {
+          bot.sendMessage(chatId, `✅ Scanned ${count} changed files.`).catch(() => {});
+        }).catch(err => {
+          bot.sendMessage(chatId, `Failed: ${err.message}`).catch(() => {});
+        });
+        return;
+      }
+
+      // Default: show status
+      const active = evolutionTracker.getActiveProposal();
+      const stats = evolutionTracker.getStats();
+      const openPRs = evolutionTracker.getPRsToCheck();
+
+      const lines = [
+        '🧬 *Self-Evolution*',
+        '',
+        `*Stats:* ${stats.totalProposals} total | ${stats.merged} merged | ${stats.rejected} rejected | ${stats.failed} failed`,
+        `*Success rate:* ${stats.successRate}%`,
+        `*Open PRs:* ${openPRs.length}`,
+      ];
+
+      if (active) {
+        const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄' }[active.status] || '•';
+        lines.push('');
+        lines.push(`*Active proposal:* ${statusIcon} \`${active.id}\` — ${active.status}`);
+        lines.push(`  ${(active.triggerContext || '').slice(0, 120)}`);
+        if (active.prUrl) lines.push(`  PR: ${active.prUrl}`);
+      } else {
+        lines.push('', '_No active proposal_');
+      }
+
+      lines.push(
+        '',
+        '_Commands:_',
+        '`/evolution history` — Recent proposals',
+        '`/evolution lessons` — Learned lessons',
+        '`/evolution trigger` — Trigger evolution now',
+        '`/evolution scan` — Scan codebase',
+      );
+
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
     if (text === '/help') {
       const activeSkill = agent.getActiveSkill(chatId);
       const skillLine = activeSkill
@@ -1117,6 +1418,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         '/jobs — List running and recent jobs',
         '/cancel — Cancel running job(s)',
         '/auto — Manage recurring automations',
+        '/life — Inner life engine status & control',
+        '/journal — View today\'s journal or a past date',
+        '/memories — View recent memories or search',
+        '/evolution — Self-evolution status, history, lessons',
         '/context — Show all models, auth, and context info',
         '/clean — Clear conversation and start fresh',
         '/history — Show message count in memory',
@@ -1293,12 +1598,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
                 });
                 return edited.message_id;
               } catch {
-                return opts.editMessageId;
+                // Edit failed — fall through to send new message
               }
             }
           }
 
-          // Send new message(s)
+          // Send new message(s) — also reached when edit fails
           const parts = splitMessage(update);
           let lastMsgId = null;
           for (const part of parts) {
@@ -1331,11 +1636,18 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           }
         };
 
+        const sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
+          await bot.setMessageReaction(targetChatId, targetMsgId, {
+            reaction: [{ type: 'emoji', emoji }],
+            is_big: isBig,
+          });
+        };
+
         logger.debug(`[Bot] Sending to orchestrator: chat ${chatId}, text="${mergedText.slice(0, 80)}"`);
         const reply = await agent.processMessage(chatId, mergedText, {
           id: userId,
           username,
-        }, onUpdate, sendPhoto);
+        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id });
 
         clearInterval(typingInterval);
 
@@ -1369,6 +1681,90 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     });
   });
 
+  // Handle message reactions (love, like, etc.)
+  bot.on('message_reaction', async (reaction) => {
+    const chatId = reaction.chat.id;
+    const userId = reaction.user?.id;
+    const username = reaction.user?.username || reaction.user?.first_name || 'unknown';
+
+    if (!userId || !isAllowedUser(userId, config)) return;
+
+    const newReactions = reaction.new_reaction || [];
+    const emojis = newReactions
+      .filter(r => r.type === 'emoji')
+      .map(r => r.emoji);
+
+    if (emojis.length === 0) return;
+
+    logger.info(`[Bot] Reaction from ${username} (${userId}) in chat ${chatId}: ${emojis.join(' ')}`);
+
+    const reactionText = `[User reacted with ${emojis.join(' ')} to your message]`;
+
+    chatQueue.enqueue(chatId, async () => {
+      try {
+        const onUpdate = async (update, opts = {}) => {
+          if (opts.editMessageId) {
+            try {
+              const edited = await bot.editMessageText(update, {
+                chat_id: chatId,
+                message_id: opts.editMessageId,
+                parse_mode: 'Markdown',
+              });
+              return edited.message_id;
+            } catch {
+              try {
+                const edited = await bot.editMessageText(update, {
+                  chat_id: chatId,
+                  message_id: opts.editMessageId,
+                });
+                return edited.message_id;
+              } catch {
+                // fall through
+              }
+            }
+          }
+          const parts = splitMessage(update);
+          let lastMsgId = null;
+          for (const part of parts) {
+            try {
+              const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
+              lastMsgId = sent.message_id;
+            } catch {
+              const sent = await bot.sendMessage(chatId, part);
+              lastMsgId = sent.message_id;
+            }
+          }
+          return lastMsgId;
+        };
+
+        const sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
+          await bot.setMessageReaction(targetChatId, targetMsgId, {
+            reaction: [{ type: 'emoji', emoji }],
+            is_big: isBig,
+          });
+        };
+
+        const reply = await agent.processMessage(chatId, reactionText, {
+          id: userId,
+          username,
+        }, onUpdate, null, { sendReaction, messageId: reaction.message_id });
+
+        if (reply && reply.trim()) {
+          const chunks = splitMessage(reply);
+          for (const chunk of chunks) {
+            try {
+              await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+            } catch {
+              await bot.sendMessage(chatId, chunk);
+            }
+          }
+        }
+      } catch (err) {
+        logger.error(`[Bot] Error processing reaction in chat ${chatId}: ${err.message}`);
+      }
+    });
+  });
+
   bot.on('polling_error', (err) => {
     logger.error(`Telegram polling error: ${err.message}`);
   });

package/src/conversation.js

@@ -68,6 +68,48 @@ export class ConversationManager {
     return this.conversations.get(key);
   }
 
+  /**
+   * Get the timestamp of the most recent message in a chat.
+   * Used by agent.js for time-gap detection before the current message is added.
+   */
+  getLastMessageTimestamp(chatId) {
+    const history = this.getHistory(chatId);
+    if (history.length === 0) return null;
+    return history[history.length - 1].timestamp || null;
+  }
+
+  /**
+   * Format a timestamp as a relative time marker.
+   * Returns null for missing timestamps (backward compat with old messages).
+   */
+  _formatRelativeTime(ts) {
+    if (!ts) return null;
+    const diff = Date.now() - ts;
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60) return '[just now]';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `[${minutes}m ago]`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return `[${hours}h ago]`;
+    const days = Math.floor(hours / 24);
+    return `[${days}d ago]`;
+  }
+
+  /**
+   * Return a shallow copy of a message with a time marker prepended to string content.
+   * Skips tool_result arrays and messages without timestamps.
+   */
+  _annotateWithTime(msg) {
+    const marker = this._formatRelativeTime(msg.timestamp);
+    if (!marker || typeof msg.content !== 'string') return msg;
+    return { ...msg, content: `${marker} ${msg.content}` };
+  }
+
+  /** Strip internal metadata fields, returning only API-safe {role, content}. */
+  _sanitize(msg) {
+    return { role: msg.role, content: msg.content };
+  }
+
   /**
    * Get history with older messages compressed into a summary.
    * Keeps the last `recentWindow` messages verbatim and summarizes older ones.
@@ -76,18 +118,19 @@ export class ConversationManager {
     const history = this.getHistory(chatId);
 
     if (history.length <= this.recentWindow) {
-      return [...history];
+      return history.map(m => this._sanitize(this._annotateWithTime(m)));
     }
 
     const olderMessages = history.slice(0, history.length - this.recentWindow);
     const recentMessages = history.slice(history.length - this.recentWindow);
 
-    // Compress older messages into a single summary
+    // Compress older messages into a single summary (include time markers when available)
     const summaryLines = olderMessages.map((msg) => {
+      const timeTag = this._formatRelativeTime(msg.timestamp);
       const content = typeof msg.content === 'string'
         ? msg.content.slice(0, 200)
         : JSON.stringify(msg.content).slice(0, 200);
-      return `[${msg.role}]: ${content}`;
+      return `[${msg.role}]${timeTag ? ` ${timeTag}` : ''}: ${content}`;
     });
 
     const summaryMessage = {
@@ -95,8 +138,11 @@ export class ConversationManager {
       content: `[CONVERSATION SUMMARY - ${olderMessages.length} earlier messages]\n${summaryLines.join('\n')}`,
     };
 
+    // Annotate recent messages with time markers and strip metadata
+    const annotatedRecent = recentMessages.map(m => this._sanitize(this._annotateWithTime(m)));
+
     // Ensure result starts with user role
-    const result = [summaryMessage, ...recentMessages];
+    const result = [summaryMessage, ...annotatedRecent];
 
     // If the first real message after summary is assistant, that's fine since
     // our summary is role:user. But ensure recent starts correctly.
@@ -105,7 +151,7 @@ export class ConversationManager {
 
   addMessage(chatId, role, content) {
     const history = this.getHistory(chatId);
-    history.push({ role, content });
+    history.push({ role, content, timestamp: Date.now() });
 
     // Trim to max history
     while (history.length > this.maxHistory) {