kernelbot 1.0.34 → 1.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",

package/src/agent.js

@@ -27,7 +27,7 @@ export class OrchestratorAgent {
     // Orchestrator provider (30s timeout — lean dispatch/summarize calls)
     const orchProviderKey = config.orchestrator.provider || 'anthropic';
     const orchProviderDef = PROVIDERS[orchProviderKey];
-    const orchApiKey = config.orchestrator.api_key || (orchProviderDef && process.env[orchProviderDef.envKey]) || process.env.ANTHROPIC_API_KEY;
+    const orchApiKey = config.orchestrator.api_key || (orchProviderDef && process.env[orchProviderDef.envKey]);
     this.orchestratorProvider = createProvider({
       brain: {
         provider: orchProviderKey,
@@ -327,6 +327,24 @@ export class OrchestratorAgent {
 
     // Build working messages from compressed history
     const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
+
+    // If an image is attached, upgrade the last user message to a multimodal content array
+    if (opts.imageAttachment) {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'user' && typeof messages[i].content === 'string') {
+          messages[i] = {
+            role: 'user',
+            content: [
+              { type: 'image', source: opts.imageAttachment },
+              { type: 'text', text: messages[i].content },
+            ],
+          };
+          break;
+        }
+      }
+      logger.info(`[Orchestrator] Image attached to message for chat ${chatId} (${opts.imageAttachment.media_type})`);
+    }
+
     logger.debug(`Orchestrator conversation context: ${messages.length} messages, max_depth=${max_tool_depth}`);
 
     const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth, temporalContext);

package/src/automation/automation-manager.js

@@ -4,6 +4,7 @@ import { homedir } from 'os';
 import { Automation } from './automation.js';
 import { scheduleNext, cancel } from './scheduler.js';
 import { getLogger } from '../utils/logger.js';
+import { isQuietHours, msUntilQuietEnd } from '../utils/timeUtils.js';
 
 const DATA_DIR = join(homedir(), '.kernelbot');
 const DATA_FILE = join(DATA_DIR, 'automations.json');
@@ -92,6 +93,7 @@ export class AutomationManager {
       name: data.name,
       description: data.description,
       schedule: data.schedule,
+      respectQuietHours: data.respectQuietHours,
     });
 
     this.automations.set(auto.id, auto);
@@ -131,6 +133,7 @@ export class AutomationManager {
 
     if (changes.name !== undefined) auto.name = changes.name;
     if (changes.description !== undefined) auto.description = changes.description;
+    if (changes.respectQuietHours !== undefined) auto.respectQuietHours = changes.respectQuietHours;
 
     if (changes.schedule !== undefined) {
       this._validateSchedule(changes.schedule);
@@ -224,6 +227,19 @@ export class AutomationManager {
       return;
     }
 
+    // Quiet-hours deferral: postpone non-essential automations until the window ends
+    if (current.respectQuietHours && isQuietHours(this._config?.life)) {
+      const deferMs = msUntilQuietEnd(this._config?.life) + 60_000; // +1 min buffer
+      logger.info(`[AutomationManager] Quiet hours — deferring "${current.name}" (${current.id}) for ${Math.round(deferMs / 60_000)}m`);
+
+      // Cancel any existing timer and re-arm to fire after quiet hours
+      this._disarm(current);
+      const timerId = setTimeout(() => this._onTimerFire(current), deferMs);
+      current.nextRun = Date.now() + deferMs;
+      this.timers.set(current.id, timerId);
+      return;
+    }
+
     // Serialize execution per chat to prevent conversation history corruption
     this._enqueueExecution(current);
   }

package/src/automation/automation.js

@@ -4,13 +4,14 @@ import { randomBytes } from 'crypto';
  * A single recurring automation — a scheduled task that the orchestrator runs.
  */
 export class Automation {
-  constructor({ chatId, name, description, schedule }) {
+  constructor({ chatId, name, description, schedule, respectQuietHours }) {
     this.id = randomBytes(4).toString('hex');
     this.chatId = String(chatId);
     this.name = name;
     this.description = description; // the task prompt
     this.schedule = schedule;       // { type, expression?, minutes?, minMinutes?, maxMinutes? }
     this.enabled = true;
+    this.respectQuietHours = respectQuietHours !== false; // default true — skip during quiet hours
     this.lastRun = null;
     this.nextRun = null;
     this.runCount = 0;
@@ -26,7 +27,8 @@ export class Automation {
       ? `next: ${new Date(this.nextRun).toLocaleString()}`
       : 'not scheduled';
     const runs = this.runCount > 0 ? ` | ${this.runCount} runs` : '';
-    return `${status} \`${this.id}\` **${this.name}** — ${scheduleStr} (${nextStr}${runs})`;
+    const quiet = this.respectQuietHours ? '' : ' | 🔔 ignores quiet hours';
+    return `${status} \`${this.id}\` **${this.name}** — ${scheduleStr} (${nextStr}${runs}${quiet})`;
   }
 
   /** Serialize for persistence. */
@@ -38,6 +40,7 @@ export class Automation {
       description: this.description,
       schedule: this.schedule,
       enabled: this.enabled,
+      respectQuietHours: this.respectQuietHours,
       lastRun: this.lastRun,
       nextRun: this.nextRun,
       runCount: this.runCount,
@@ -55,6 +58,7 @@ export class Automation {
     auto.description = data.description;
     auto.schedule = data.schedule;
     auto.enabled = data.enabled;
+    auto.respectQuietHours = data.respectQuietHours !== false; // backward-compat: default true
     auto.lastRun = data.lastRun;
     auto.nextRun = data.nextRun;
     auto.runCount = data.runCount;

package/src/bot.js

@@ -1,6 +1,6 @@
 import TelegramBot from 'node-telegram-bot-api';
 import { createReadStream, readFileSync } from 'fs';
-import { isAllowedUser, getUnauthorizedMessage } from './security/auth.js';
+import { isAllowedUser, getUnauthorizedMessage, alertAdmin } from './security/auth.js';
 import { getLogger } from './utils/logger.js';
 import { PROVIDERS } from './providers/models.js';
 import {
@@ -15,6 +15,7 @@ import {
 import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
+import { isQuietHours } from './utils/timeUtils.js';
 
 /**
  * Simulate a human-like typing delay based on response length.
@@ -43,6 +44,27 @@ async function simulateTypingDelay(bot, chatId, text) {
   return new Promise((resolve) => setTimeout(resolve, finalDelay));
 }
 
+/**
+ * Simulate a brief pause between consecutive message chunks.
+ * When a long reply is split into multiple Telegram messages, firing them
+ * all instantly feels robotic. This adds a short, natural delay with a
+ * typing indicator so multi-part replies feel more human.
+ *
+ * @param {TelegramBot} bot - Telegram bot instance
+ * @param {number} chatId - Chat to show typing in
+ * @param {string} nextChunk - The upcoming chunk (used to scale the pause)
+ * @returns {Promise<void>}
+ */
+async function simulateInterChunkDelay(bot, chatId, nextChunk) {
+  // Shorter than the initial typing delay: 0.3s – 1.5s based on chunk length
+  const length = (nextChunk || '').length;
+  const base = Math.min(1500, Math.max(300, length * 8));
+  const jitter = base * (0.85 + Math.random() * 0.3);
+
+  bot.sendChatAction(chatId, 'typing').catch(() => {});
+  return new Promise((resolve) => setTimeout(resolve, Math.round(jitter)));
+}
+
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
 
@@ -67,6 +89,7 @@ function splitMessage(text, maxLength = 4096) {
  * Tries Markdown first, falls back to plain text.
  */
 function createOnUpdate(bot, chatId) {
+  const logger = getLogger();
   return async (update, opts = {}) => {
     if (opts.editMessageId) {
       try {
@@ -76,15 +99,16 @@ function createOnUpdate(bot, chatId) {
           parse_mode: 'Markdown',
         });
         return edited.message_id;
-      } catch {
+      } catch (mdErr) {
+        logger.debug(`[Bot] Markdown edit failed for chat ${chatId}, retrying plain: ${mdErr.message}`);
         try {
           const edited = await bot.editMessageText(update, {
             chat_id: chatId,
             message_id: opts.editMessageId,
           });
           return edited.message_id;
-        } catch {
-          // Edit failed — fall through to send new message
+        } catch (plainErr) {
+          logger.debug(`[Bot] Plain-text edit also failed for chat ${chatId}, sending new message: ${plainErr.message}`);
         }
       }
     }
@@ -94,7 +118,8 @@ function createOnUpdate(bot, chatId) {
       try {
         const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
         lastMsgId = sent.message_id;
-      } catch {
+      } catch (mdErr) {
+        logger.debug(`[Bot] Markdown send failed for chat ${chatId}, falling back to plain: ${mdErr.message}`);
         const sent = await bot.sendMessage(chatId, part);
         lastMsgId = sent.message_id;
       }
@@ -142,6 +167,7 @@ function createSendReaction(bot) {
 /**
  * Simple per-chat queue to serialize agent processing.
  * Each chat gets its own promise chain so messages are processed in order.
+ * Automatically cleans up finished queues to avoid unbounded Map growth.
  */
 class ChatQueue {
   constructor() {
@@ -149,9 +175,21 @@ class ChatQueue {
   }
 
   enqueue(chatId, fn) {
+    const logger = getLogger();
     const key = String(chatId);
     const prev = this.queues.get(key) || Promise.resolve();
-    const next = prev.then(() => fn()).catch(() => {});
+    const next = prev
+      .then(() => fn())
+      .catch((err) => {
+        logger.error(`[ChatQueue] Error processing message for chat ${key}: ${err.message}`);
+      })
+      .finally(() => {
+        // Clean up the queue entry once this is the last item in the chain,
+        // preventing the Map from growing unboundedly over long-running sessions.
+        if (this.queues.get(key) === next) {
+          this.queues.delete(key);
+        }
+      });
     this.queues.set(key, next);
     return next;
   }
@@ -252,6 +290,13 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
     if (!isAllowedUser(query.from.id, config)) {
       await bot.answerCallbackQuery(query.id, { text: 'Unauthorized' });
+      await alertAdmin(bot, {
+        userId: query.from.id,
+        username: query.from.username,
+        firstName: query.from.first_name,
+        text: `🔘 زر: ${query.data || 'unknown'}`,
+        type: 'callback',
+      });
       return;
     }
 
@@ -741,6 +786,13 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       if (msg.text || msg.document) {
         logger.warn(`Unauthorized access attempt from ${username} (${userId})`);
         await bot.sendMessage(chatId, getUnauthorizedMessage());
+        await alertAdmin(bot, {
+          userId,
+          username: msg.from.username,
+          firstName: msg.from.first_name,
+          text: msg.text || (msg.document ? `📎 ملف: ${msg.document.file_name || 'unknown'}` : undefined),
+          type: 'رسالة',
+        });
       }
       return;
     }
@@ -806,6 +858,37 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       }
     }
 
+    // Handle photo messages — download, convert to base64, and pass to LLM for vision analysis
+    let imageAttachment = null;
+    if (msg.photo && msg.photo.length > 0) {
+      logger.info(`[Bot] Photo message from ${username} (${userId}) in chat ${chatId}`);
+      try {
+        // Use highest resolution (last item in array)
+        const photo = msg.photo[msg.photo.length - 1];
+        const fileLink = await bot.getFileLink(photo.file_id);
+        const response = await fetch(fileLink);
+        if (!response.ok) throw new Error(`Failed to download photo: ${response.statusText}`);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const base64Data = buffer.toString('base64');
+
+        // Determine media type from URL extension, default to jpeg
+        const ext = fileLink.split('.').pop().split('?')[0].toLowerCase();
+        const extToMime = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', gif: 'image/gif', webp: 'image/webp' };
+        const mediaType = extToMime[ext] || 'image/jpeg';
+
+        imageAttachment = { type: 'base64', media_type: mediaType, data: base64Data };
+        // Use caption as text, or default prompt
+        if (!msg.text) {
+          msg.text = msg.caption || 'What do you see in this image? Describe it in detail.';
+        }
+        logger.info(`[Bot] Photo downloaded and encoded (${Math.round(base64Data.length / 1024)}KB base64, ${mediaType})`);
+      } catch (err) {
+        logger.error(`[Bot] Photo processing failed: ${err.message}`);
+        await bot.sendMessage(chatId, 'Failed to process the image. Please try again.');
+        return;
+      }
+    }
+
     if (!msg.text) return; // ignore non-text (and non-document) messages
 
     let text = msg.text.trim();
@@ -1646,7 +1729,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         const reply = await agent.processMessage(chatId, mergedText, {
           id: userId,
           username,
-        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id });
+        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id, imageAttachment });
 
         clearInterval(typingInterval);
 
@@ -1655,17 +1738,21 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
         logger.info(`[Bot] Reply for chat ${chatId}: ${(reply || '').length} chars`);
         const chunks = splitMessage(reply || 'Done.');
-        for (const chunk of chunks) {
+        for (let i = 0; i < chunks.length; i++) {
+          // Brief pause between consecutive chunks so multi-part replies feel natural
+          if (i > 0) await simulateInterChunkDelay(bot, chatId, chunks[i]);
           try {
-            await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+            await bot.sendMessage(chatId, chunks[i], { parse_mode: 'Markdown' });
           } catch {
             // Fallback to plain text if Markdown fails
-            await bot.sendMessage(chatId, chunk);
+            await bot.sendMessage(chatId, chunks[i]);
           }
         }
 
-        // Send voice reply if TTS is available and the reply isn't too short
-        if (ttsService.isAvailable() && reply && reply.length > 5) {
+        // Send voice reply only when the user explicitly requests it
+        const voiceKeywords = ['صوت', 'صوتك', 'صوتية', 'صوتي', 'voice', 'speak', 'hear you'];
+        const wantsVoice = voiceKeywords.some((kw) => mergedText.toLowerCase().includes(kw));
+        if (wantsVoice && ttsService.isAvailable() && reply && reply.length > 5) {
           try {
             const audioPath = await ttsService.synthesize(reply);
             if (audioPath) {
@@ -1689,7 +1776,18 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const userId = reaction.user?.id;
     const username = reaction.user?.username || reaction.user?.first_name || 'unknown';
 
-    if (!userId || !isAllowedUser(userId, config)) return;
+    if (!userId || !isAllowedUser(userId, config)) {
+      if (userId) {
+        await alertAdmin(bot, {
+          userId,
+          username: reaction.user?.username,
+          firstName: reaction.user?.first_name,
+          text: `${(reaction.new_reaction || []).filter(r => r.type === 'emoji').map(r => r.emoji).join(' ') || 'reaction'}`,
+          type: 'تفاعل',
+        });
+      }
+      return;
+    }
 
     const newReactions = reaction.new_reaction || [];
     const emojis = newReactions
@@ -1703,6 +1801,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const reactionText = `[User reacted with ${emojis.join(' ')} to your message]`;
 
     chatQueue.enqueue(chatId, async () => {
+      // Show typing indicator while processing the reaction
+      const typingInterval = setInterval(() => {
+        bot.sendChatAction(chatId, 'typing').catch(() => {});
+      }, 4000);
+      bot.sendChatAction(chatId, 'typing').catch(() => {});
+
       try {
         const onUpdate = createOnUpdate(bot, chatId);
         const sendReaction = createSendReaction(bot);
@@ -1712,17 +1816,24 @@ export function startBot(config, agent, conversationManager, jobManager, automat
           username,
         }, onUpdate, null, { sendReaction, messageId: reaction.message_id });
 
+        clearInterval(typingInterval);
+
         if (reply && reply.trim()) {
+          // Simulate human-like typing delay before responding to the reaction
+          await simulateTypingDelay(bot, chatId, reply);
+
           const chunks = splitMessage(reply);
-          for (const chunk of chunks) {
+          for (let i = 0; i < chunks.length; i++) {
+            if (i > 0) await simulateInterChunkDelay(bot, chatId, chunks[i]);
             try {
-              await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+              await bot.sendMessage(chatId, chunks[i], { parse_mode: 'Markdown' });
             } catch {
-              await bot.sendMessage(chatId, chunk);
+              await bot.sendMessage(chatId, chunks[i]);
             }
           }
         }
       } catch (err) {
+        clearInterval(typingInterval);
         logger.error(`[Bot] Error processing reaction in chat ${chatId}: ${err.message}`);
       }
     });
@@ -1749,10 +1860,6 @@ export function startBot(config, agent, conversationManager, jobManager, automat
   }, 5000);
 
   // ── Proactive share delivery (randomized, self-rearming) ────
-  const lifeConfig = config.life || {};
-  const quietStart = lifeConfig.quiet_hours?.start ?? 2;
-  const quietEnd = lifeConfig.quiet_hours?.end ?? 6;
-
   const armShareDelivery = (delivered) => {
     // If we just delivered something, wait longer (1–4h) before next check
     // If nothing was delivered, check again sooner (10–45min) in case new shares appear
@@ -1763,9 +1870,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     logger.debug(`[Bot] Next share check in ${Math.round(delayMs / 60_000)}m`);
 
     setTimeout(async () => {
-      // Respect quiet hours
-      const hour = new Date().getHours();
-      if (hour >= quietStart && hour < quietEnd) {
+      // Respect quiet hours (env vars → YAML config → defaults 02:00–06:00)
+      if (isQuietHours(config.life)) {
         armShareDelivery(false);
         return;
       }

package/src/life/engine.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
+import { isQuietHours } from '../utils/timeUtils.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const STATE_FILE = join(LIFE_DIR, 'state.json');
@@ -195,12 +196,8 @@ export class LifeEngine {
     const logger = getLogger();
     this._timerId = null;
 
-    // Check quiet hours
-    const lifeConfig = this.config.life || {};
-    const quietStart = lifeConfig.quiet_hours?.start ?? 2;
-    const quietEnd = lifeConfig.quiet_hours?.end ?? 6;
-    const currentHour = new Date().getHours();
-    if (currentHour >= quietStart && currentHour < quietEnd) {
+    // Check quiet hours (env vars → YAML config → defaults 02:00–06:00)
+    if (isQuietHours(this.config.life)) {
       logger.debug('[LifeEngine] Quiet hours — skipping tick');
       this._armNext();
       return;
@@ -407,31 +404,9 @@ This is your private thought space — be genuine, be curious, be alive.`;
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract ideas
-      const ideaLines = response.split('\n').filter(l => l.trim().startsWith('IDEA:'));
-      for (const line of ideaLines) {
-        this._addIdea(line.replace(/^IDEA:\s*/, '').trim());
-      }
-
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'think', 'medium');
-      }
-
-      // Extract questions to ask users
-      const askLines = response.split('\n').filter(l => l.trim().startsWith('ASK:'));
-      for (const line of askLines) {
-        this.shareQueue.add(line.replace(/^ASK:\s*/, '').trim(), 'think', 'medium', null, ['question']);
-      }
+      const extracted = this._extractTaggedLines(response, ['IDEA', 'SHARE', 'ASK', 'IMPROVE']);
+      this._processResponseTags(extracted, 'think');
 
-      // Extract self-improvement proposals for evolution pipeline
-      const improveLines = response.split('\n').filter(l => l.trim().startsWith('IMPROVE:'));
-      for (const line of improveLines) {
-        this._addIdea(`[IMPROVE] ${line.replace(/^IMPROVE:\s*/, '').trim()}`);
-      }
-
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'thought',
         source: 'think',
@@ -440,7 +415,7 @@ This is your private thought space — be genuine, be curious, be alive.`;
         importance: 3,
       });
 
-      logger.info(`[LifeEngine] Think complete (${response.length} chars, ${ideaLines.length} ideas, ${shareLines.length} shares, ${askLines.length} questions, ${improveLines.length} improvements)`);
+      logger.info(`[LifeEngine] Think complete (${response.length} chars, ${extracted.IDEA.length} ideas, ${extracted.SHARE.length} shares, ${extracted.ASK.length} questions, ${extracted.IMPROVE.length} improvements)`);
     }
   }
 
@@ -477,25 +452,9 @@ If you learn a key fact or concept, prefix it with "LEARNED:" followed by "topic
     const response = await this._dispatchWorker('research', prompt);
 
     if (response) {
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'browse', 'medium');
-      }
-
-      // Extract learned facts
-      const learnedLines = response.split('\n').filter(l => l.trim().startsWith('LEARNED:'));
-      for (const line of learnedLines) {
-        const content = line.replace(/^LEARNED:\s*/, '').trim();
-        const colonIdx = content.indexOf(':');
-        if (colonIdx > 0) {
-          const topicKey = content.slice(0, colonIdx).trim();
-          const summary = content.slice(colonIdx + 1).trim();
-          this.memoryManager.addSemantic(topicKey, { summary });
-        }
-      }
+      const extracted = this._extractTaggedLines(response, ['SHARE', 'LEARNED']);
+      this._processResponseTags(extracted, 'browse');
 
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'discovery',
         source: 'browse',
@@ -594,10 +553,10 @@ Respond with just your creation — no tool calls needed.`;
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'create', 'medium', null, ['creation']);
+      const extracted = this._extractTaggedLines(response, ['SHARE']);
+      // Creative shares get a 'creation' tag for richer attribution
+      for (const text of extracted.SHARE) {
+        this.shareQueue.add(text, 'create', 'medium', null, ['creation']);
       }
 
       this.memoryManager.addEpisodic({
@@ -1203,23 +1162,11 @@ Be honest and constructive. This is your chance to learn from real interactions.
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract improvement ideas
-      const improveLines = response.split('\n').filter(l => l.trim().startsWith('IMPROVE:'));
-      for (const line of improveLines) {
-        this._addIdea(`[IMPROVE] ${line.replace(/^IMPROVE:\s*/, '').trim()}`);
-      }
-
-      // Extract patterns as semantic memories
-      const patternLines = response.split('\n').filter(l => l.trim().startsWith('PATTERN:'));
-      for (const line of patternLines) {
-        const content = line.replace(/^PATTERN:\s*/, '').trim();
-        this.memoryManager.addSemantic('interaction_patterns', { summary: content });
-      }
+      const extracted = this._extractTaggedLines(response, ['IMPROVE', 'PATTERN']);
+      this._processResponseTags(extracted, 'reflect');
 
-      // Write a journal entry with the reflection
       this.journalManager.writeEntry('Interaction Reflection', response);
 
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'thought',
         source: 'reflect',
@@ -1228,7 +1175,7 @@ Be honest and constructive. This is your chance to learn from real interactions.
         importance: 5,
       });
 
-      logger.info(`[LifeEngine] Reflection complete (${response.length} chars, ${improveLines.length} improvements, ${patternLines.length} patterns)`);
+      logger.info(`[LifeEngine] Reflection complete (${response.length} chars, ${extracted.IMPROVE.length} improvements, ${extracted.PATTERN.length} patterns)`);
     }
   }
 
@@ -1307,6 +1254,78 @@ Be honest and constructive. This is your chance to learn from real interactions.
 
   // ── Utilities ──────────────────────────────────────────────────
 
+  /**
+   * Extract tagged lines from an LLM response.
+   * Tags are prefixes like "SHARE:", "IDEA:", "IMPROVE:", etc. that the LLM
+   * uses to signal structured intents within free-form text.
+   *
+   * @param {string} response - Raw LLM response text.
+   * @param {string[]} tags - List of tag prefixes to extract (e.g. ['SHARE', 'IDEA']).
+   * @returns {Record<string, string[]>} Map of tag → array of extracted values (prefix stripped, trimmed).
+   */
+  _extractTaggedLines(response, tags) {
+    const lines = response.split('\n');
+    const result = {};
+    for (const tag of tags) {
+      result[tag] = [];
+    }
+    for (const line of lines) {
+      const trimmed = line.trim();
+      for (const tag of tags) {
+        if (trimmed.startsWith(`${tag}:`)) {
+          result[tag].push(trimmed.slice(tag.length + 1).trim());
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Process common tagged lines from an activity response, routing each tag
+   * to the appropriate handler (share queue, ideas backlog, semantic memory).
+   *
+   * @param {Record<string, string[]>} extracted - Output from _extractTaggedLines.
+   * @param {string} source - Activity source for share queue attribution (e.g. 'think', 'browse').
+   */
+  _processResponseTags(extracted, source) {
+    if (extracted.SHARE) {
+      for (const text of extracted.SHARE) {
+        this.shareQueue.add(text, source, 'medium');
+      }
+    }
+    if (extracted.IDEA) {
+      for (const text of extracted.IDEA) {
+        this._addIdea(text);
+      }
+    }
+    if (extracted.IMPROVE) {
+      for (const text of extracted.IMPROVE) {
+        this._addIdea(`[IMPROVE] ${text}`);
+      }
+    }
+    if (extracted.ASK) {
+      for (const text of extracted.ASK) {
+        this.shareQueue.add(text, source, 'medium', null, ['question']);
+      }
+    }
+    if (extracted.LEARNED) {
+      for (const text of extracted.LEARNED) {
+        const colonIdx = text.indexOf(':');
+        if (colonIdx > 0) {
+          const topicKey = text.slice(0, colonIdx).trim();
+          const summary = text.slice(colonIdx + 1).trim();
+          this.memoryManager.addSemantic(topicKey, { summary });
+        }
+      }
+    }
+    if (extracted.PATTERN) {
+      for (const text of extracted.PATTERN) {
+        this.memoryManager.addSemantic('interaction_patterns', { summary: text });
+      }
+    }
+  }
+
   _formatDuration(ms) {
     const hours = Math.floor(ms / 3600_000);
     const minutes = Math.floor((ms % 3600_000) / 60_000);

package/src/life/evolution.js

@@ -1,16 +1,13 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { getStartOfDayMs } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const EVOLUTION_FILE = join(LIFE_DIR, 'evolution.json');
 
-function genId(prefix = 'evo') {
-  return `${prefix}_${randomBytes(4).toString('hex')}`;
-}
-
 const VALID_STATUSES = ['research', 'planned', 'coding', 'pr_open', 'merged', 'rejected', 'failed'];
 const TERMINAL_STATUSES = ['merged', 'rejected', 'failed'];
 
@@ -231,9 +228,8 @@ export class EvolutionTracker {
   }
 
   getProposalsToday() {
-    const startOfDay = new Date();
-    startOfDay.setHours(0, 0, 0, 0);
-    return this._data.proposals.filter(p => p.createdAt >= startOfDay.getTime());
+    const cutoff = getStartOfDayMs();
+    return this._data.proposals.filter(p => p.createdAt >= cutoff);
   }
 
   // ── Internal ──────────────────────────────────────────────────