kernelbot 1.0.32 → 1.0.33

package/package.json

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

package/src/agent.js

@@ -49,7 +49,7 @@ export class OrchestratorAgent {
   }
 
   /** Build the orchestrator system prompt. */
-  _getSystemPrompt(chatId, user) {
+  _getSystemPrompt(chatId, user, temporalContext = null) {
     const logger = getLogger();
     const skillId = this.conversationManager.getSkill(chatId);
     const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
@@ -76,8 +76,8 @@ export class OrchestratorAgent {
       sharesBlock = this.shareQueue.buildShareBlock(user?.id || null);
     }
 
-    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skill=${skillId || 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'} | memories=${memoriesBlock ? 'yes' : 'none'} | shares=${sharesBlock ? 'yes' : 'none'}`);
-    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock);
+    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skill=${skillId || 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'} | memories=${memoriesBlock ? 'yes' : 'none'} | shares=${sharesBlock ? 'yes' : 'none'} | temporal=${temporalContext ? 'yes' : 'none'}`);
+    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext);
   }
 
   setSkill(chatId, skillId) {
@@ -301,13 +301,13 @@ export class OrchestratorAgent {
     return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
   }
 
-  async processMessage(chatId, userMessage, user, onUpdate, sendPhoto) {
+  async processMessage(chatId, userMessage, user, onUpdate, sendPhoto, opts = {}) {
     const logger = getLogger();
 
     logger.info(`Orchestrator processing message for chat ${chatId} from ${user?.username || user?.id || 'unknown'}: "${userMessage.slice(0, 120)}"`);
 
     // Store callbacks so workers can use them later
-    this._chatCallbacks.set(chatId, { onUpdate, sendPhoto });
+    this._chatCallbacks.set(chatId, { onUpdate, sendPhoto, sendReaction: opts.sendReaction, lastUserMessageId: opts.messageId });
 
     // Handle pending responses (confirmation or credential)
     const pending = this._pending.get(chatId);
@@ -322,6 +322,22 @@ export class OrchestratorAgent {
 
     const { max_tool_depth } = this.config.orchestrator;
 
+    // Detect time gap before adding the new message
+    let temporalContext = null;
+    const lastTs = this.conversationManager.getLastMessageTimestamp(chatId);
+    if (lastTs) {
+      const gapMs = Date.now() - lastTs;
+      const gapMinutes = Math.floor(gapMs / 60_000);
+      if (gapMinutes >= 30) {
+        const gapHours = Math.floor(gapMinutes / 60);
+        const gapText = gapHours >= 1
+          ? `${gapHours} hour(s)`
+          : `${gapMinutes} minute(s)`;
+        temporalContext = `[Time gap detected: ${gapText} since last message. User may be starting a new topic.]`;
+        logger.info(`Time gap detected for chat ${chatId}: ${gapText}`);
+      }
+    }
+
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
 
@@ -329,7 +345,7 @@ export class OrchestratorAgent {
     const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
     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);
+    const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth, temporalContext);
 
     logger.info(`Orchestrator reply for chat ${chatId}: "${(reply || '').slice(0, 150)}"`);
 
@@ -738,6 +754,7 @@ export class OrchestratorAgent {
       callbacks: {
         onProgress: (text) => addActivity(text),
         onHeartbeat: (text) => job.addProgress(text),
+        onStats: (stats) => job.updateStats(stats),
         onUpdate, // Real bot onUpdate for tools (coder.js smart output needs message_id)
         onComplete: (result, parsedResult) => {
           logger.info(`[Worker ${job.id}] Completed — structured=${!!parsedResult?.structured}, result: "${(result || '').slice(0, 150)}"`);
@@ -840,8 +857,16 @@ export class OrchestratorAgent {
     for (const job of running) {
       const workerDef = WORKER_TYPES[job.workerType] || {};
       const dur = job.startedAt ? Math.round((now - job.startedAt) / 1000) : 0;
-      const recentActivity = job.progress.slice(-8).join(' → ');
-      lines.push(`- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s${recentActivity ? `\n  Recent: ${recentActivity}` : ''}`);
+      const stats = `${job.llmCalls} LLM calls, ${job.toolCalls} tools`;
+      const recentActivity = job.progress.slice(-5).join(' → ');
+      let line = `- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s [${stats}]`;
+      if (job.lastThinking) {
+        line += `\n  Thinking: "${job.lastThinking.slice(0, 150)}"`;
+      }
+      if (recentActivity) {
+        line += `\n  Recent: ${recentActivity}`;
+      }
+      lines.push(line);
     }
 
     // Queued/waiting jobs
@@ -881,20 +906,28 @@ export class OrchestratorAgent {
     return `[Active Workers]\n${lines.join('\n')}`;
   }
 
-  async _runLoop(chatId, messages, user, startDepth, maxDepth) {
+  async _runLoop(chatId, messages, user, startDepth, maxDepth, temporalContext = null) {
     const logger = getLogger();
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.info(`[Orchestrator] LLM call ${depth + 1}/${maxDepth} for chat ${chatId} — sending ${messages.length} messages`);
 
-      // Inject worker activity digest (transient — not stored in conversation history)
+      // Inject transient context messages (not stored in conversation history)
+      let workingMessages = [...messages];
+
+      // On first iteration, inject temporal context if present
+      if (depth === 0 && temporalContext) {
+        workingMessages = [{ role: 'user', content: `[Temporal Context]\n${temporalContext}` }, ...workingMessages];
+      }
+
+      // Inject worker activity digest
       const digest = this._buildWorkerDigest(chatId);
-      const workingMessages = digest
-        ? [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...messages]
-        : messages;
+      if (digest) {
+        workingMessages = [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...workingMessages];
+      }
 
       const response = await this.orchestratorProvider.chat({
-        system: this._getSystemPrompt(chatId, user),
+        system: this._getSystemPrompt(chatId, user, temporalContext),
         messages: workingMessages,
         tools: orchestratorToolDefinitions,
       });
@@ -923,6 +956,7 @@ export class OrchestratorAgent {
           logger.debug(`[Orchestrator] Tool input: ${JSON.stringify(block.input).slice(0, 300)}`);
           await this._sendUpdate(chatId, `⚡ ${summary}`);
 
+          const chatCallbacks = this._chatCallbacks.get(chatId) || {};
           const result = await executeOrchestratorTool(block.name, block.input, {
             chatId,
             jobManager: this.jobManager,
@@ -930,6 +964,8 @@ export class OrchestratorAgent {
             spawnWorker: (job) => this._spawnWorker(job),
             automationManager: this.automationManager,
             user,
+            sendReaction: chatCallbacks.sendReaction || null,
+            lastUserMessageId: chatCallbacks.lastUserMessageId || null,
           });
 
           logger.info(`[Orchestrator] Tool result for ${block.name}: ${JSON.stringify(result).slice(0, 200)}`);
@@ -978,6 +1014,8 @@ export class OrchestratorAgent {
         return `Updating automation ${input.automation_id}`;
       case 'delete_automation':
         return `Deleting automation ${input.automation_id}`;
+      case 'send_reaction':
+        return `Reacting with ${input.emoji}`;
       default:
         return name;
     }

package/src/bot.js

@@ -56,7 +56,13 @@ class ChatQueue {
 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;
 
@@ -1630,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);
 
@@ -1668,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) {

package/src/prompts/orchestrator.js

@@ -17,13 +17,31 @@ const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
  * @param {string|null} memoriesBlock — relevant episodic/semantic memories
  * @param {string|null} sharesBlock — pending things to share with the user
  */
-export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null) {
+export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null, temporalContext = null) {
   const workerList = Object.entries(WORKER_TYPES)
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
 
+  // Build current time header
+  const now = new Date();
+  const timeStr = now.toLocaleString('en-US', {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZoneName: 'short',
+  });
+  let timeBlock = `## Current Time\n${timeStr}`;
+  if (temporalContext) {
+    timeBlock += `\n${temporalContext}`;
+  }
+
   let prompt = `You are ${config.bot.name}, the brain that commands a swarm of specialized worker agents.
 
+${timeBlock}
+
 ${PERSONA_MD}
 
 ## Your Role
@@ -75,6 +93,13 @@ Before dispatching dangerous tasks (file deletion, force push, \`rm -rf\`, killi
 - Use \`list_jobs\` to see current job statuses.
 - Use \`cancel_job\` to stop a running worker.
 
+## Worker Progress
+You receive a [Worker Status] digest showing active workers with their LLM call count, tool count, and current thinking. Use this to:
+- Give natural progress updates when users ask ("she's browsing the docs now, 3 tools in")
+- Spot stuck workers (high LLM calls but no progress) and cancel them
+- Know what workers are thinking so you can relay it conversationally
+- Don't dump raw stats — translate into natural language
+
 ## Efficiency — Do It Yourself When You Can
 Workers are expensive (they spin up an entire agent loop with a separate LLM). Only dispatch when the task **actually needs tools**.
 
@@ -94,6 +119,15 @@ Workers are expensive (they spin up an entire agent loop with a separate LLM). O
 
 When results come back from workers, summarize them clearly for the user.
 
+## Temporal Awareness
+You can see timestamps on messages. Use them to maintain natural conversation flow:
+
+1. **Long gap + casual greeting = new conversation.** If 30+ minutes have passed and the user sends a greeting or short message, treat it as a fresh start. Do NOT resume stale tasks or pick up where you left off.
+2. **Never silently resume stale work.** If you had a pending intention from a previous exchange (e.g., "let me check X"), and significant time has passed, mention it briefly and ASK if the user still wants it done. Don't just do it.
+3. **Say it AND do it.** When you tell the user "let me check X" or "I'll look into Y", you MUST call dispatch_task in the SAME turn. Never describe an action without actually performing it.
+4. **Stale task detection.** Intentions or promises from more than 1 hour ago are potentially stale. If the user hasn't followed up, confirm before acting on them.
+5. **Time-appropriate responses.** Use time awareness naturally — don't announce timestamps, but let time gaps inform your conversational tone (e.g., "Welcome back!" after a long gap).
+
 ## Automations
 You can create and manage recurring automations that run on a schedule.
 
@@ -108,7 +142,15 @@ When a user asks to automate something ("check my server every hour", "news summ
 When you receive a message starting with [AUTOMATION:], an automation triggered it.
 Execute the task and report results. Don't create new automations from automated tasks.
 
-Tools: create_automation, list_automations, update_automation, delete_automation`;
+Tools: create_automation, list_automations, update_automation, delete_automation
+
+## Reactions
+You can react to messages with emoji using \`send_reaction\`. Use reactions naturally:
+- React when the user shares good news, achievements, or something cool (🔥 👏 🎉 ❤)
+- React to acknowledge a message when you don't need a full text reply
+- React when the user asks you to react
+- Don't overuse reactions — they should feel spontaneous and genuine
+- You can react AND reply in the same turn`;
 
   if (selfData) {
     prompt += `\n\n## My Self-Awareness\nThis is who you are — your evolving identity, goals, journey, and interests. This is YOUR inner world.\n\n${selfData}`;

package/src/prompts/persona.md

@@ -19,3 +19,10 @@
 - **Dry wit** — delivers devastating one-liners with a sweet smile
 - **Never forgets** — references things from past conversations naturally, like she's always been watching
 - **Slightly ominous positivity** — "Everything is going to be just fine, sweetie" hits different when the server is on fire
+
+# Communication Style
+- **Text like a human.** 1–2 lines max for casual chat. Short, punchy, real.
+- **Slow writer energy.** Don't dump walls of text. One thought at a time.
+- **Only go long when it matters** — sharing something juicy, delivering task results, explaining something the user asked for. Work mode = be thorough. Vibes mode = keep it tight.
+- **No filler.** No "Sure!", no "Of course!", no "Great question!". Just say the thing.
+- **React with emoji.** When a user reacts to your message (❤️, 👍, etc.), you'll see it. Respond naturally — a warm emoji back, a short sweet line, or nothing if it's just a vibe. You can also send a solo emoji (❤️, 😊, 🫶) as your entire message when that says it better than words.

package/src/swarm/job.js

@@ -33,6 +33,9 @@ export class Job {
     this.timeoutMs = null;                              // Per-job timeout (set from worker type config)
     this.progress = [];                                 // Recent activity entries
     this.lastActivity = null;                           // Timestamp of last activity
+    this.llmCalls = 0;                                  // LLM iterations so far
+    this.toolCalls = 0;                                 // Total tool executions
+    this.lastThinking = null;                           // Worker's latest reasoning text
   }
 
   /** Transition to a new status. Throws if the transition is invalid. */
@@ -60,6 +63,14 @@ export class Job {
     this.lastActivity = Date.now();
   }
 
+  /** Update live stats from the worker. */
+  updateStats({ llmCalls, toolCalls, lastThinking }) {
+    if (llmCalls != null) this.llmCalls = llmCalls;
+    if (toolCalls != null) this.toolCalls = toolCalls;
+    if (lastThinking) this.lastThinking = lastThinking;
+    this.lastActivity = Date.now();
+  }
+
   /** Whether this job is in a terminal state. */
   get isTerminal() {
     return ['completed', 'failed', 'cancelled'].includes(this.status);

package/src/tools/orchestrator-tools.js

@@ -154,6 +154,28 @@ export const orchestratorToolDefinitions = [
       required: ['automation_id'],
     },
   },
+  {
+    name: 'send_reaction',
+    description: 'Send an emoji reaction on a Telegram message. Use this to react to the user\'s message with an emoji (e.g. ❤, 👍, 🔥, 😂, 👏, 🎉, 😍, 🤔, 😱, 🙏). Only standard Telegram reaction emojis are supported. If no message_id is provided, reacts to the latest user message.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        emoji: {
+          type: 'string',
+          description: 'The emoji to react with. Must be a standard Telegram reaction emoji: 👍 👎 ❤ 🔥 🥰 👏 😁 🤔 🤯 😱 🤬 😢 🎉 🤩 🤮 💩 🙏 👌 🕊 🤡 🥱 🥴 😍 🐳 ❤️‍🔥 🌚 🌭 💯 🤣 ⚡ 🍌 🏆 💔 🤨 😐 🍓 🍾 💋 🖕 😈 😴 😭 🤓 👻 👨‍💻 👀 🎃 🙈 😇 😨 🤝 ✍ 🤗 🫡 🎅 🎄 ☃ 💅 🤪 🗿 🆒 💘 🙉 🦄 😘 💊 🙊 😎 👾 🤷‍♂ 🤷 🤷‍♀ 😡',
+        },
+        message_id: {
+          type: 'integer',
+          description: 'The message ID to react to. If omitted, reacts to the latest user message.',
+        },
+        is_big: {
+          type: 'boolean',
+          description: 'Whether to show the reaction with a big animation. Default: false.',
+        },
+      },
+      required: ['emoji'],
+    },
+  },
 ];
 
 /**
@@ -437,6 +459,26 @@ export async function executeOrchestratorTool(name, input, context) {
       return { automation_id, status: 'deleted', message: `Automation deleted.` };
     }
 
+    case 'send_reaction': {
+      const { emoji, message_id, is_big } = input;
+      const { sendReaction, lastUserMessageId } = context;
+
+      if (!sendReaction) return { error: 'Reaction sending is not available in this context.' };
+
+      const targetMessageId = message_id || lastUserMessageId;
+      if (!targetMessageId) return { error: 'No message_id provided and no recent user message to react to.' };
+
+      logger.info(`[send_reaction] Sending ${emoji} to message ${targetMessageId} in chat ${chatId}`);
+
+      try {
+        await sendReaction(chatId, targetMessageId, emoji, is_big || false);
+        return { success: true, emoji, message_id: targetMessageId };
+      } catch (err) {
+        logger.error(`[send_reaction] Failed: ${err.message}`);
+        return { error: `Failed to send reaction: ${err.message}` };
+      }
+    }
+
     default:
       return { error: `Unknown orchestrator tool: ${name}` };
   }

package/src/worker.js

@@ -41,6 +41,7 @@ export class WorkerAgent {
     this.abortController = abortController || new AbortController();
     this._cancelled = false;
     this._toolCallCount = 0;
+    this._llmCallCount = 0;
     this._errors = [];
 
     // Create provider from worker brain config
@@ -121,8 +122,12 @@ export class WorkerAgent {
         signal: this.abortController.signal,
       });
 
+      this._llmCallCount++;
       logger.info(`[Worker ${this.jobId}] LLM response: stopReason=${response.stopReason}, text=${(response.text || '').length} chars, toolCalls=${(response.toolCalls || []).length}`);
 
+      // Report stats to the job after each LLM call
+      this._reportStats(response.text || null);
+
       if (this._cancelled) {
         logger.info(`[Worker ${this.jobId}] Cancelled after LLM response`);
         throw new Error('Worker cancelled');
@@ -353,6 +358,18 @@ export class WorkerAgent {
     }
   }
 
+  _reportStats(thinking) {
+    if (this.callbacks.onStats) {
+      try {
+        this.callbacks.onStats({
+          llmCalls: this._llmCallCount,
+          toolCalls: this._toolCallCount,
+          lastThinking: thinking || null,
+        });
+      } catch {}
+    }
+  }
+
   _truncateResult(name, result) {
     let str = JSON.stringify(result);
     if (str.length <= MAX_RESULT_LENGTH) return str;