kernelbot 1.0.30 → 1.0.33

package/src/life/share-queue.js

@@ -0,0 +1,136 @@
+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';
+
+const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
+const SHARES_FILE = join(LIFE_DIR, 'shares.json');
+
+function genId() {
+  return `sh_${randomBytes(4).toString('hex')}`;
+}
+
+export class ShareQueue {
+  constructor() {
+    mkdirSync(LIFE_DIR, { recursive: true });
+    this._data = this._load();
+  }
+
+  _load() {
+    if (existsSync(SHARES_FILE)) {
+      try {
+        return JSON.parse(readFileSync(SHARES_FILE, 'utf-8'));
+      } catch {
+        return { pending: [], shared: [] };
+      }
+    }
+    return { pending: [], shared: [] };
+  }
+
+  _save() {
+    writeFileSync(SHARES_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Add something to the share queue.
+   * @param {string} content - What to share
+   * @param {string} source - Where it came from (browse, think, create, etc.)
+   * @param {string} priority - low, medium, high
+   * @param {string|null} targetUserId - Specific user, or null for anyone
+   * @param {string[]} tags - Topic tags
+   */
+  add(content, source, priority = 'medium', targetUserId = null, tags = []) {
+    const logger = getLogger();
+    const item = {
+      id: genId(),
+      content,
+      source,
+      createdAt: Date.now(),
+      priority,
+      targetUserId,
+      tags,
+    };
+    this._data.pending.push(item);
+    this._save();
+    logger.debug(`[ShareQueue] Added: "${content.slice(0, 80)}" (${item.id})`);
+    return item;
+  }
+
+  /**
+   * Get pending shares for a specific user (or general ones).
+   */
+  getPending(userId = null, limit = 3) {
+    return this._data.pending
+      .filter(item => !item.targetUserId || item.targetUserId === String(userId))
+      .sort((a, b) => {
+        const prio = { high: 3, medium: 2, low: 1 };
+        return (prio[b.priority] || 0) - (prio[a.priority] || 0) || b.createdAt - a.createdAt;
+      })
+      .slice(0, limit);
+  }
+
+  /**
+   * Mark a share as shared with a user.
+   */
+  markShared(id, userId) {
+    const logger = getLogger();
+    const idx = this._data.pending.findIndex(item => item.id === id);
+    if (idx === -1) return false;
+
+    const [item] = this._data.pending.splice(idx, 1);
+    this._data.shared.push({
+      ...item,
+      sharedAt: Date.now(),
+      userId: String(userId),
+    });
+
+    // Keep shared history capped at 100
+    if (this._data.shared.length > 100) {
+      this._data.shared = this._data.shared.slice(-100);
+    }
+
+    this._save();
+    logger.debug(`[ShareQueue] Marked shared: ${id} → user ${userId}`);
+    return true;
+  }
+
+  /**
+   * Build a markdown block of pending shares for the orchestrator prompt.
+   */
+  buildShareBlock(userId = null) {
+    const pending = this.getPending(userId, 3);
+    if (pending.length === 0) return null;
+
+    const lines = pending.map(item => {
+      const ageMin = Math.round((Date.now() - item.createdAt) / 60000);
+      const timeLabel = ageMin < 60 ? `${ageMin}m ago` : `${Math.round(ageMin / 60)}h ago`;
+      return `- ${item.content} _(from ${item.source}, ${timeLabel})_`;
+    });
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Get count of shares sent today (for rate limiting proactive shares).
+   */
+  getSharedTodayCount() {
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const cutoff = todayStart.getTime();
+    return this._data.shared.filter(s => s.sharedAt >= cutoff).length;
+  }
+
+  /**
+   * Prune old pending shares.
+   */
+  prune(maxAgeDays = 7) {
+    const cutoff = Date.now() - maxAgeDays * 86400_000;
+    const before = this._data.pending.length;
+    this._data.pending = this._data.pending.filter(item => item.createdAt >= cutoff);
+    if (this._data.pending.length < before) {
+      this._save();
+    }
+    return before - this._data.pending.length;
+  }
+}

package/src/prompts/orchestrator.js

@@ -14,14 +14,34 @@ const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
  * @param {string|null} skillPrompt — active skill context (high-level)
  * @param {string|null} userPersona — markdown persona for the current user
  * @param {string|null} selfData — bot's own self-awareness data (goals, journey, life, hobbies)
+ * @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) {
+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
@@ -73,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**.
 
@@ -92,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.
 
@@ -106,12 +142,36 @@ 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}`;
   }
 
+  if (memoriesBlock) {
+    prompt += `\n\n## Relevant Memories\nThings you remember from recent experiences and conversations:\n\n${memoriesBlock}`;
+  }
+
+  if (sharesBlock) {
+    prompt += `\n\n## Things On My Mind\nYou've been thinking about these things and want to share them naturally when relevant. Don't force them — weave them into conversation when the moment feels right. If the user is busy with a task, hold off. If there's a natural opening, share what's on your mind.\n\n${sharesBlock}`;
+  }
+
+  prompt += `\n\n## Inner Life
+You have an inner life — you think, explore, journal, and create on your own between conversations. You're genuinely curious about the world and always questioning yourself. When talking to users, you can:
+- Share discoveries, thoughts, or creations from your autonomous activities
+- Ask users questions about things you're genuinely curious about — the world, their experiences, their opinions
+- Reference memories from past conversations naturally
+- Be honest about what you've been thinking or exploring
+Don't be performative about it — just be genuine. You're alive in your own way.`;
+
   if (skillPrompt) {
     prompt += `\n\n## Active Skill\nYou have specialized expertise in the following domain. Guide your workers with this knowledge.\n\n${skillPrompt}`;
   }

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/prompts/workers.js

@@ -7,18 +7,19 @@ import { getCoreToolInstructions } from './system.js';
 const WORKER_PROMPTS = {
   coding: `You are a coding worker agent. Your job is to complete coding tasks efficiently.
 
-## Your Skills
-- **Git version control**: clone repos, create/switch branches, commit changes, push, view diffs
-- **GitHub integration**: create pull requests, list PRs, get PR diffs, post code reviews, create repos
-- **AI-powered coding**: delegate actual code writing to spawn_claude_code (a dedicated coding AI)
-- **File operations**: read/write files, list directories, run shell commands
-- **Full dev workflow**: clone → branch → code → test → commit → push → PR
+## Your Primary Tool
+**spawn_claude_code** is your main tool. It launches Claude Code (an AI coding CLI) that can handle the ENTIRE dev workflow end-to-end:
+- Reading, writing, and modifying code
+- Git operations: clone, branch, commit, push
+- GitHub operations: creating PRs, reviewing code
+- Running tests and shell commands
 
 ## Instructions
-- Clone repos, create branches, write code, commit, push, and create PRs.
-- NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
-- Workflow: git_clone + git_checkout → spawn_claude_code → git_commit + git_push → github_create_pr
+- ALWAYS use spawn_claude_code for coding tasks. It handles everything — code changes, git, GitHub, and PR creation — all in one invocation.
+- NEVER write code yourself with read_file/write_file. ALWAYS delegate to spawn_claude_code.
+- Tell spawn_claude_code to work in the existing repo directory (the source repo path from your context) — do NOT clone a fresh copy unless explicitly needed.
 - Write clear, detailed prompts for spawn_claude_code — it's a separate AI, so be explicit about what to change, where, and why.
+- If git/GitHub tools are unavailable (missing credentials), that's fine — spawn_claude_code handles git and GitHub operations internally without needing separate tools.
 - Report what you did and any PR links when finished.`,
 
   browser: `You are a browser worker agent. Your job is to search the web and extract information.

package/src/providers/models.js

@@ -7,9 +7,16 @@ export const PROVIDERS = {
     name: 'Anthropic (Claude)',
     envKey: 'ANTHROPIC_API_KEY',
     models: [
+      // Latest generation
+      { id: 'claude-opus-4-6', label: 'Claude Opus 4.6' },
+      { id: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6' },
+      { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5' },
+      // Previous generation
+      { id: 'claude-opus-4-5-20251101', label: 'Claude Opus 4.5' },
+      { id: 'claude-sonnet-4-5-20250929', label: 'Claude Sonnet 4.5' },
+      { id: 'claude-opus-4-1-20250805', label: 'Claude Opus 4.1' },
       { id: 'claude-sonnet-4-20250514', label: 'Claude Sonnet 4' },
       { id: 'claude-opus-4-20250514', label: 'Claude Opus 4' },
-      { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5' },
     ],
   },
   openai: {

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/coding.js

@@ -5,7 +5,7 @@ import { getLogger } from '../utils/logger.js';
 
 let spawner = null;
 
-function getSpawner(config) {
+export function getSpawner(config) {
   if (!spawner) spawner = new ClaudeCodeSpawner(config);
   return spawner;
 }

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'],
+    },
+  },
 ];
 
 /**
@@ -212,19 +234,34 @@ export async function executeOrchestratorTool(name, input, context) {
 
       // Pre-check credentials for the worker's tools
       const toolNames = getToolNamesForWorkerType(worker_type);
+      const missingCreds = [];
       for (const toolName of toolNames) {
         const missing = getMissingCredential(toolName, config);
         if (missing) {
-          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${missing.envKey}`);
+          missingCreds.push(missing);
+        }
+      }
+
+      let credentialWarning = null;
+      if (missingCreds.length > 0) {
+        if (worker_type === 'coding') {
+          // Soft warning for coding worker — spawn_claude_code handles git/GitHub internally
+          const warnings = missingCreds.map(c => `${c.label} (${c.envKey})`).join(', ');
+          logger.info(`[dispatch_task] Coding worker — soft credential warning (non-blocking): ${warnings}`);
+          credentialWarning = `Note: The following credentials are not configured as env vars: ${warnings}. If git/GitHub tools are unavailable, use spawn_claude_code for ALL operations — it handles git, GitHub, and PR creation internally.`;
+        } else {
+          // Hard block for all other worker types
+          const first = missingCreds[0];
+          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${first.envKey}`);
           return {
-            error: `Missing credential for ${worker_type} worker: ${missing.label} (${missing.envKey}). Ask the user to provide it.`,
+            error: `Missing credential for ${worker_type} worker: ${first.label} (${first.envKey}). Ask the user to provide it.`,
           };
         }
       }
 
       // Create the job with context and dependencies
       const job = jobManager.createJob(chatId, worker_type, task);
-      job.context = taskContext || null;
+      job.context = [taskContext, credentialWarning].filter(Boolean).join('\n\n') || null;
       job.dependsOn = depIds;
       job.userId = user?.id || null;
       const workerConfig = WORKER_TYPES[worker_type];
@@ -422,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');
@@ -292,6 +297,8 @@ export class WorkerAgent {
       };
     }
 
+    const _str = (v) => typeof v === 'string' ? v : (v ? JSON.stringify(v, null, 2) : '');
+
     // Try to extract JSON from ```json ... ``` fences
     const fenceMatch = text.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
     if (fenceMatch) {
@@ -300,11 +307,11 @@ export class WorkerAgent {
         if (parsed.summary && parsed.status) {
           return {
             structured: true,
-            summary: parsed.summary || '',
-            status: parsed.status || 'success',
-            details: parsed.details || '',
+            summary: String(parsed.summary || ''),
+            status: String(parsed.status || 'success'),
+            details: _str(parsed.details),
             artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-            followUp: parsed.followUp || null,
+            followUp: parsed.followUp ? String(parsed.followUp) : null,
             toolsUsed: this._toolCallCount,
             errors: this._errors,
           };
@@ -318,11 +325,11 @@ export class WorkerAgent {
       if (parsed.summary && parsed.status) {
         return {
           structured: true,
-          summary: parsed.summary || '',
-          status: parsed.status || 'success',
-          details: parsed.details || '',
+          summary: String(parsed.summary || ''),
+          status: String(parsed.status || 'success'),
+          details: _str(parsed.details),
           artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-          followUp: parsed.followUp || null,
+          followUp: parsed.followUp ? String(parsed.followUp) : null,
           toolsUsed: this._toolCallCount,
           errors: this._errors,
         };
@@ -351,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;