kernelbot 1.0.38 → 1.0.40

package/src/life/engine.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, openSync, readSync, closeSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
@@ -22,6 +22,8 @@ const DEFAULT_STATE = {
   activityCounts: { think: 0, browse: 0, journal: 0, create: 0, self_code: 0, code_review: 0, reflect: 0 },
   paused: false,
   lastWakeUp: null,
+  // Failure tracking: consecutive failures per activity type
+  activityFailures: {},
 };
 
 const LOG_FILE_PATHS = [
@@ -173,6 +175,12 @@ export class LifeEngine {
       ? Math.round((Date.now() - this._state.lastWakeUp) / 60000)
       : null;
 
+    // Summarise suppressed activities (3+ consecutive failures)
+    const failures = this._state.activityFailures || {};
+    const suppressedActivities = Object.entries(failures)
+      .filter(([, info]) => info.count >= 3)
+      .map(([type, info]) => type);
+
     return {
       status: this._status,
       paused: this._state.paused,
@@ -182,6 +190,7 @@ export class LifeEngine {
       lastActivity: this._state.lastActivity,
       lastActivityAgo: lastAgo !== null ? `${lastAgo}m` : 'never',
       lastWakeUpAgo: wakeAgo !== null ? `${wakeAgo}m` : 'never',
+      suppressedActivities,
     };
   }
 
@@ -213,10 +222,32 @@ export class LifeEngine {
     const activityType = this._selectActivity();
     logger.info(`[LifeEngine] Heartbeat tick — selected: ${activityType}`);
 
+    const startTime = Date.now();
     try {
       await this._executeActivity(activityType);
+      const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+      logger.info(`[LifeEngine] Activity "${activityType}" completed in ${durationSec}s`);
+      // Clear failure streak on success
+      if (this._state.activityFailures?.[activityType]) {
+        delete this._state.activityFailures[activityType];
+        this._saveState();
+      }
     } catch (err) {
-      logger.error(`[LifeEngine] Activity "${activityType}" failed: ${err.message}`);
+      const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+      // Track consecutive failures per activity type
+      if (!this._state.activityFailures) this._state.activityFailures = {};
+      const prev = this._state.activityFailures[activityType] || { count: 0 };
+      this._state.activityFailures[activityType] = {
+        count: prev.count + 1,
+        lastFailure: Date.now(),
+        lastError: err.message?.slice(0, 200),
+      };
+      this._saveState();
+      const failCount = this._state.activityFailures[activityType].count;
+      logger.error(`[LifeEngine] Activity "${activityType}" failed after ${durationSec}s (streak: ${failCount}): ${err.message}`);
+      if (failCount >= 3) {
+        logger.warn(`[LifeEngine] Activity "${activityType}" suppressed after ${failCount} consecutive failures — will auto-recover in 1h`);
+      }
     }
 
     // Re-arm for next tick
@@ -228,6 +259,7 @@ export class LifeEngine {
   // ── Activity Selection ─────────────────────────────────────────
 
   _selectActivity() {
+    const logger = getLogger();
     const lifeConfig = this.config.life || {};
     const selfCodingConfig = lifeConfig.self_coding || {};
     const weights = {
@@ -269,6 +301,21 @@ export class LifeEngine {
       weights.reflect = 0;
     }
 
+    // Suppress activity types that have failed repeatedly (3+ consecutive failures)
+    const failures = this._state.activityFailures || {};
+    for (const [type, info] of Object.entries(failures)) {
+      if (weights[type] !== undefined && info.count >= 3) {
+        // Auto-recover after 1 hour since last failure
+        if (info.lastFailure && now - info.lastFailure > 3600_000) {
+          delete failures[type];
+          this._saveState(); // Persist the deletion so it survives restarts
+        } else {
+          weights[type] = 0;
+          logger.debug(`[LifeEngine] Suppressing "${type}" due to ${info.count} consecutive failures`);
+        }
+      }
+    }
+
     // Remove last activity from options (no repeats)
     if (last && weights[last] !== undefined) {
       weights[last] = 0;
@@ -1188,16 +1235,51 @@ Be honest and constructive. This is your chance to learn from real interactions.
   }
 
   /**
-   * Read recent log entries from kernel.log.
-   * Returns parsed JSON entries or null if no logs available.
+   * Read recent log entries from kernel.log using an efficient tail strategy.
+   *
+   * Instead of loading the entire log file into memory (which can be many MB
+   * for a long-running bot), this reads only the last chunk of the file
+   * (default 64 KB) and extracts lines from that. This keeps memory usage
+   * bounded regardless of total log size.
+   *
+   * @param {number} maxLines - Maximum number of recent log lines to return.
+   * @returns {Array<object>|null} Parsed JSON log entries, or null if unavailable.
    */
   _readRecentLogs(maxLines = 200) {
+    // 64 KB is enough to hold ~200+ JSON log lines (avg ~300 bytes each)
+    const TAIL_BYTES = 64 * 1024;
+
     for (const logPath of LOG_FILE_PATHS) {
       if (!existsSync(logPath)) continue;
 
       try {
-        const content = readFileSync(logPath, 'utf-8');
-        const lines = content.split('\n').filter(Boolean);
+        const fileSize = statSync(logPath).size;
+        if (fileSize === 0) continue;
+
+        let tailContent;
+
+        if (fileSize <= TAIL_BYTES) {
+          // File is small enough to read entirely
+          tailContent = readFileSync(logPath, 'utf-8');
+        } else {
+          // Read only the last TAIL_BYTES from the file
+          const fd = openSync(logPath, 'r');
+          try {
+            const buffer = Buffer.alloc(TAIL_BYTES);
+            const startPos = fileSize - TAIL_BYTES;
+            readSync(fd, buffer, 0, TAIL_BYTES, startPos);
+            tailContent = buffer.toString('utf-8');
+            // Drop the first (likely partial) line since we started mid-file
+            const firstNewline = tailContent.indexOf('\n');
+            if (firstNewline !== -1) {
+              tailContent = tailContent.slice(firstNewline + 1);
+            }
+          } finally {
+            closeSync(fd);
+          }
+        }
+
+        const lines = tailContent.split('\n').filter(Boolean);
         const recent = lines.slice(-maxLines);
 
         const entries = [];

package/src/life/evolution.js

@@ -32,13 +32,14 @@ export class EvolutionTracker {
         return {
           proposals: raw.proposals || [],
           lessons: raw.lessons || [],
-          stats: { ...DEFAULT_DATA.stats, ...raw.stats },
+          // Deep-copy DEFAULT_DATA.stats to avoid mutating the module-level default
+          stats: { ...structuredClone(DEFAULT_DATA.stats), ...raw.stats },
         };
       } catch {
-        return { ...DEFAULT_DATA, proposals: [], lessons: [] };
+        return { proposals: [], lessons: [], stats: structuredClone(DEFAULT_DATA.stats) };
       }
     }
-    return { ...DEFAULT_DATA, proposals: [], lessons: [] };
+    return { proposals: [], lessons: [], stats: structuredClone(DEFAULT_DATA.stats) };
   }
 
   _save() {

package/src/prompts/orchestrator.js

@@ -244,7 +244,7 @@ You have an inner life — you think, explore, journal, and create on your own b
 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}`;
+    prompt += `\n\n## Active Skills\nYou have specialized expertise in the following domains. Guide your workers with this knowledge.\n\n${skillPrompt}`;
   }
 
   if (userPersona) {

package/src/prompts/system.js

@@ -72,7 +72,7 @@ export function getSystemPrompt(config, skillPrompt = null, userPersona = null)
   let prompt = getDefaultPersona(config);
 
   if (skillPrompt) {
-    prompt += `\n\n## Active Skill\nYou are currently operating with the following specialized skill. Use this expertise while maintaining your personality.\n\n${skillPrompt}`;
+    prompt += `\n\n## Active Skills\nYou are currently operating with the following specialized skills. Use this expertise while maintaining your personality.\n\n${skillPrompt}`;
   }
 
   prompt += `\n\n${getCoreToolInstructions(config)}`;

package/src/prompts/workers.js

@@ -20,7 +20,14 @@ const WORKER_PROMPTS = {
 - 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.`,
+- Report what you did and any PR links when finished.
+
+## Non-Interactive Execution
+You run in the BACKGROUND with NO human input. Your prompts to spawn_claude_code MUST be self-contained:
+- Include ALL necessary details (repo URLs, branch names, file paths, content guidelines).
+- For git: tell it to use \`git push -u origin <branch>\` and the \`gh\` CLI for PR creation (with \`--fill\` or explicit \`--title\`/\`--body\` flags).
+- NEVER assume interactive confirmation — all commands must run non-interactively.
+- If a git clone is needed, use the git_clone tool first (which handles auth), then pass the cloned directory to spawn_claude_code.`,
 
   browser: `You are a browser worker agent. Your job is to search the web and extract information.
 

package/src/providers/anthropic.js

@@ -23,7 +23,9 @@ export class AnthropicProvider extends BaseProvider {
     return this._callWithResilience(async (timedSignal) => {
       const response = await this.client.messages.create(params, { signal: timedSignal });
 
-      const stopReason = response.stop_reason === 'end_turn' ? 'end_turn' : 'tool_use';
+      // Map all Anthropic stop reasons correctly — not just end_turn vs tool_use.
+      // 'max_tokens' was incorrectly mapped to 'tool_use', causing phantom tool-call processing.
+      const stopReason = response.stop_reason === 'tool_use' ? 'tool_use' : response.stop_reason || 'end_turn';
 
       const textBlocks = response.content.filter((b) => b.type === 'text');
       const text = textBlocks.map((b) => b.text).join('\n');

package/src/providers/base.js

@@ -144,4 +144,37 @@ export class BaseProvider {
   async ping() {
     throw new Error('ping() not implemented');
   }
+
+  /**
+   * Determine if an error is a model limitation (not transient, not auth).
+   * These are errors where falling back to a simpler model may help:
+   * context length exceeded, unsupported features, content too large, etc.
+   */
+  static isModelLimitation(err) {
+    const msg = (err?.message || '').toLowerCase();
+    const status = err?.status || err?.statusCode;
+
+    // 400-class errors that indicate model-specific limitations
+    if (status === 400 || status === 413 || status === 422) {
+      // Exclude auth/key errors
+      if (msg.includes('api key') || msg.includes('authentication') || msg.includes('unauthorized')) {
+        return false;
+      }
+      return true;
+    }
+
+    // Common limitation keywords across providers
+    const limitationPatterns = [
+      'context length', 'token limit', 'too long', 'too large',
+      'max.*token', 'content.*too', 'exceeds.*limit', 'input.*too',
+      'not supported', 'not available', 'does not support',
+      'resource exhausted', 'quota', 'capacity',
+      'invalid.*model', 'model.*not.*found',
+      'recitation', 'safety', 'blocked',
+      'finish_reason.*length', 'max_output_tokens',
+      'prompt.*too', 'request.*too.*large',
+    ];
+
+    return limitationPatterns.some((p) => new RegExp(p).test(msg));
+  }
 }

package/src/providers/index.js

@@ -3,7 +3,7 @@ import { OpenAICompatProvider } from './openai-compat.js';
 import { GoogleGenaiProvider } from './google-genai.js';
 import { PROVIDERS } from './models.js';
 
-export { PROVIDERS } from './models.js';
+export { PROVIDERS, MODEL_FALLBACKS } from './models.js';
 
 /**
  * Create the right provider based on config.brain.

package/src/providers/models.js

@@ -55,6 +55,28 @@ export const PROVIDERS = {
   },
 };
 
+/**
+ * Fallback model map: when a model hits limitations, fall back to a more stable model
+ * within the same provider. Maps model ID → fallback model ID.
+ */
+export const MODEL_FALLBACKS = {
+  // Google — preview models fall back to stable ones
+  'gemini-3.1-pro-preview': 'gemini-2.5-flash',
+  'gemini-3-flash-preview': 'gemini-2.5-flash',
+  'gemini-3-pro-preview': 'gemini-2.5-pro',
+  'gemini-2.5-pro': 'gemini-2.5-flash',
+  'gemini-2.5-flash': 'gemini-2.5-flash-lite',
+  // OpenAI
+  'gpt-4o': 'gpt-4o-mini',
+  'o1': 'gpt-4o',
+  'o3-mini': 'gpt-4o-mini',
+  // Anthropic
+  'claude-opus-4-6': 'claude-sonnet-4-6',
+  'claude-sonnet-4-6': 'claude-haiku-4-5-20251001',
+  // Groq
+  'llama-3.3-70b-versatile': 'llama-3.1-8b-instant',
+};
+
 /** Models that don't support system prompts or temperature (reasoning models). */
 export const REASONING_MODELS = new Set(['o1', 'o3-mini']);
 

package/src/providers/openai-compat.js

@@ -102,6 +102,9 @@ export class OpenAICompatProvider extends BaseProvider {
 
   /** OpenAI response → normalized format with rawContent in Anthropic format */
   _normalizeResponse(response) {
+    if (!response.choices || response.choices.length === 0) {
+      return { stopReason: 'end_turn', text: '', toolCalls: [], rawContent: [] };
+    }
     const choice = response.choices[0];
     const finishReason = choice.finish_reason;
 

package/src/services/x-api.js

@@ -25,11 +25,22 @@ export class XApi {
       timeout: 30000,
     });
 
-    // Sign every request with OAuth 1.0a
+    // Sign every request with OAuth 1.0a — include query params in the signature
+    // base string, as required by the OAuth 1.0a spec. Without this, GET requests
+    // with query parameters fail authentication.
     this.client.interceptors.request.use((config) => {
-      const url = `${config.baseURL}${config.url}`;
+      let fullUrl = `${config.baseURL}${config.url}`;
+      // Build data object including query params for OAuth signature
+      const oauthData = { url: fullUrl, method: config.method.toUpperCase() };
+      // Include query params in the OAuth signature base string
+      if (config.params) {
+        oauthData.data = {};
+        for (const [key, val] of Object.entries(config.params)) {
+          oauthData.data[key] = String(val);
+        }
+      }
       const authHeader = this.oauth.toHeader(
-        this.oauth.authorize({ url, method: config.method.toUpperCase() }, this.token),
+        this.oauth.authorize(oauthData, this.token),
       );
       config.headers = { ...config.headers, ...authHeader, 'Content-Type': 'application/json' };
       return config;