kernelbot 1.0.37 → 1.0.39

package/src/dashboard/shared.js

@@ -0,0 +1,218 @@
+/**
+ * KERNEL Dashboard — Shared utilities, SSE, gauges, canvas animations.
+ * Exposed on window.KERNEL for use by page-specific scripts.
+ */
+(function() {
+  // ── Utilities ──
+  function esc(s) {
+    if (!s) return '';
+    return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+  }
+
+  function formatDuration(seconds) {
+    if (seconds == null || seconds < 0) return '--';
+    const s = Math.floor(seconds);
+    if (s < 60) return s + 's';
+    if (s < 3600) return Math.floor(s/60) + 'm ' + (s%60) + 's';
+    return Math.floor(s/3600) + 'h ' + Math.floor((s%3600)/60) + 'm';
+  }
+
+  function timeAgo(ts) {
+    if (!ts) return 'never';
+    const s = Math.floor((Date.now() - ts)/1000);
+    if (s < 60) return 'just now';
+    if (s < 3600) return Math.floor(s/60) + 'm ago';
+    if (s < 86400) return Math.floor(s/3600) + 'h ago';
+    return Math.floor(s/86400) + 'd ago';
+  }
+
+  function formatBytes(b) {
+    if (b < 1024) return b + ' B';
+    if (b < 1048576) return (b/1024).toFixed(1) + ' KB';
+    if (b < 1073741824) return (b/1048576).toFixed(1) + ' MB';
+    return (b/1073741824).toFixed(2) + ' GB';
+  }
+
+  function barColor(pct) { return pct < 50 ? 'green' : pct < 80 ? 'amber' : 'red'; }
+
+  function makeBar(label, pct, color) {
+    return `<div class="row"><span class="k">${esc(label)}</span><span class="v">${pct.toFixed(1)}%</span></div><div class="bar-track"><div class="bar-fill ${color || barColor(pct)}" style="width:${Math.min(pct,100)}%"></div></div>`;
+  }
+
+  const $ = id => document.getElementById(id);
+
+  // ── Clock ──
+  function startClock() {
+    setInterval(() => {
+      const now = new Date();
+      const p = n => String(n).padStart(2,'0');
+      const full = now.getFullYear() + '.' + p(now.getMonth()+1) + '.' + p(now.getDate()) + ' ' + p(now.getHours()) + ':' + p(now.getMinutes()) + ':' + p(now.getSeconds());
+      const hdrClock = $('hdr-clock');
+      if (hdrClock) hdrClock.textContent = full;
+      const rbClock = $('rb-clock');
+      if (rbClock) rbClock.textContent = p(now.getHours()) + ':' + p(now.getMinutes());
+    }, 1000);
+  }
+
+  // ── Gauge helpers ──
+  function setGauge(id, pct, label) {
+    const el = $(id);
+    if (!el) return;
+    const circumference = parseFloat(el.querySelector('.fill').getAttribute('stroke-dasharray'));
+    const offset = circumference * (1 - Math.min(pct, 100) / 100);
+    const fill = el.querySelector('.fill');
+    fill.style.strokeDashoffset = offset;
+    fill.classList.remove('amber', 'red');
+    if (pct >= 80) fill.classList.add('red');
+    else if (pct >= 50) fill.classList.add('amber');
+    const pctEl = el.querySelector('.pct');
+    if (pctEl) {
+      pctEl.textContent = pct.toFixed(0) + '%';
+      pctEl.classList.remove('amber','red');
+      if (pct >= 80) pctEl.classList.add('red');
+      else if (pct >= 50) pctEl.classList.add('amber');
+    }
+    const sub = el.querySelector('.sub');
+    if (sub && label) sub.textContent = label;
+  }
+
+  function setMiniGauge(id, pct) {
+    const el = $(id);
+    if (!el) return;
+    const fill = el.querySelector('.fill');
+    const circumference = parseFloat(fill.getAttribute('stroke-dasharray'));
+    fill.style.strokeDashoffset = circumference * (1 - Math.min(pct, 100) / 100);
+    fill.classList.remove('amber','red');
+    if (pct >= 80) fill.classList.add('red');
+    else if (pct >= 50) fill.classList.add('amber');
+    el.querySelector('.val').textContent = pct.toFixed(0) + '%';
+  }
+
+  // ── SSE Connection ──
+  function connectSSE(onSnapshot) {
+    let reconnectDelay = 1000;
+    function connect() {
+      const es = new EventSource('/events');
+      es.onopen = () => {
+        reconnectDelay = 1000;
+        const connDot = $('conn-dot');
+        if (connDot) connDot.classList.add('connected');
+        const topConn = $('top-conn');
+        if (topConn) topConn.classList.add('connected');
+        const hdrStatus = $('hdr-status');
+        if (hdrStatus) hdrStatus.textContent = 'ONLINE';
+      };
+      es.onmessage = (evt) => {
+        try {
+          const data = JSON.parse(evt.data);
+          onSnapshot(data);
+        } catch(e) {
+          if (e instanceof SyntaxError) {
+            console.debug('[Dashboard] Malformed SSE message (invalid JSON)');
+          } else {
+            console.warn('[Dashboard] Snapshot handler error:', e.message || e);
+          }
+        }
+      };
+      es.onerror = () => {
+        es.close();
+        const connDot = $('conn-dot');
+        if (connDot) connDot.classList.remove('connected');
+        const topConn = $('top-conn');
+        if (topConn) topConn.classList.remove('connected');
+        const hdrStatus = $('hdr-status');
+        if (hdrStatus) hdrStatus.textContent = 'RECONNECTING';
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 1.5, 15000);
+      };
+    }
+    connect();
+  }
+
+  // ── Particle Grid Canvas ──
+  function initParticleCanvas() {
+    const canvas = $('particle-canvas');
+    if (!canvas) return;
+    const ctx = canvas.getContext('2d');
+    let w, h;
+    const GRID = 50;
+
+    function resize() {
+      w = canvas.width = window.innerWidth;
+      h = canvas.height = window.innerHeight;
+      drawGrid();
+    }
+
+    function drawGrid() {
+      ctx.clearRect(0, 0, w, h);
+      ctx.strokeStyle = 'rgba(57,255,20,0.02)';
+      ctx.lineWidth = 0.5;
+      for (let x = 0; x <= w; x += GRID) {
+        ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, h); ctx.stroke();
+      }
+      for (let y = 0; y <= h; y += GRID) {
+        ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(w, y); ctx.stroke();
+      }
+    }
+
+    resize();
+    window.addEventListener('resize', resize);
+  }
+
+  // ── Waveform Canvas ──
+  function initWaveform() {
+    const canvas = $('waveform-canvas');
+    if (!canvas) return;
+    const ctx = canvas.getContext('2d');
+    let w, h, phase = 0;
+
+    function resize() {
+      const parent = canvas.parentElement;
+      w = canvas.width = parent.offsetWidth;
+      h = canvas.height = parent.offsetHeight;
+    }
+    resize();
+    window.addEventListener('resize', resize);
+
+    const waves = [
+      { freq: 0.015, amp: 0.25, speed: 0.02, alpha: 0.5, width: 1.5 },
+      { freq: 0.025, amp: 0.15, speed: 0.035, alpha: 0.3, width: 1 },
+      { freq: 0.04,  amp: 0.08, speed: 0.05, alpha: 0.15, width: 0.8 },
+    ];
+
+    function draw() {
+      requestAnimationFrame(draw);
+      ctx.clearRect(0, 0, w, h);
+      for (const wave of waves) {
+        ctx.beginPath();
+        ctx.strokeStyle = `rgba(57,255,20,${wave.alpha})`;
+        ctx.lineWidth = wave.width;
+        for (let x = 0; x < w; x++) {
+          const y = h/2 + Math.sin(x * wave.freq + phase * wave.speed * 60) * h * wave.amp
+                       + Math.sin(x * wave.freq * 2.3 + phase * wave.speed * 40) * h * wave.amp * 0.4;
+          x === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
+        }
+        ctx.stroke();
+      }
+      phase += 0.016;
+    }
+    requestAnimationFrame(draw);
+  }
+
+  // ── Expose on window.KERNEL ──
+  window.KERNEL = {
+    esc,
+    formatDuration,
+    timeAgo,
+    formatBytes,
+    barColor,
+    makeBar,
+    $,
+    startClock,
+    setGauge,
+    setMiniGauge,
+    connectSSE,
+    initParticleCanvas,
+    initWaveform,
+  };
+})();

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';
@@ -8,7 +8,7 @@ const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const STATE_FILE = join(LIFE_DIR, 'state.json');
 const IDEAS_FILE = join(LIFE_DIR, 'ideas.json');
 
-const LIFE_CHAT_ID = '__life__';
+const DEFAULT_LIFE_CHAT_ID = '__life__';
 const LIFE_USER = { id: 'life_engine', username: 'inner_self' };
 
 const DEFAULT_STATE = {
@@ -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 = [
@@ -33,7 +35,7 @@ export class LifeEngine {
   /**
    * @param {{ config: object, agent: object, memoryManager: object, journalManager: object, shareQueue: object, improvementTracker?: object, evolutionTracker?: object, codebaseKnowledge?: object, selfManager: object }} deps
    */
-  constructor({ config, agent, memoryManager, journalManager, shareQueue, improvementTracker, evolutionTracker, codebaseKnowledge, selfManager }) {
+  constructor({ config, agent, memoryManager, journalManager, shareQueue, improvementTracker, evolutionTracker, codebaseKnowledge, selfManager, basePath = null, characterId = null }) {
     this.config = config;
     this.agent = agent;
     this.memoryManager = memoryManager;
@@ -46,17 +48,24 @@ export class LifeEngine {
     this.selfManager = selfManager;
     this._timerId = null;
     this._status = 'idle'; // idle, active, paused
+    this._characterId = characterId || null;
 
-    mkdirSync(LIFE_DIR, { recursive: true });
+    this._lifeDir = basePath || LIFE_DIR;
+    this._stateFile = join(this._lifeDir, 'state.json');
+    this._ideasFile = join(this._lifeDir, 'ideas.json');
+
+    this._lifeChatId = this._characterId ? `__life__:${this._characterId}` : DEFAULT_LIFE_CHAT_ID;
+
+    mkdirSync(this._lifeDir, { recursive: true });
     this._state = this._loadState();
   }
 
   // ── State Persistence ──────────────────────────────────────────
 
   _loadState() {
-    if (existsSync(STATE_FILE)) {
+    if (existsSync(this._stateFile)) {
       try {
-        return { ...DEFAULT_STATE, ...JSON.parse(readFileSync(STATE_FILE, 'utf-8')) };
+        return { ...DEFAULT_STATE, ...JSON.parse(readFileSync(this._stateFile, 'utf-8')) };
       } catch {
         return { ...DEFAULT_STATE };
       }
@@ -65,20 +74,20 @@ export class LifeEngine {
   }
 
   _saveState() {
-    writeFileSync(STATE_FILE, JSON.stringify(this._state, null, 2), 'utf-8');
+    writeFileSync(this._stateFile, JSON.stringify(this._state, null, 2), 'utf-8');
   }
 
   // ── Ideas Backlog ──────────────────────────────────────────────
 
   _loadIdeas() {
-    if (existsSync(IDEAS_FILE)) {
-      try { return JSON.parse(readFileSync(IDEAS_FILE, 'utf-8')); } catch { return []; }
+    if (existsSync(this._ideasFile)) {
+      try { return JSON.parse(readFileSync(this._ideasFile, 'utf-8')); } catch { return []; }
     }
     return [];
   }
 
   _saveIdeas(ideas) {
-    writeFileSync(IDEAS_FILE, JSON.stringify(ideas, null, 2), 'utf-8');
+    writeFileSync(this._ideasFile, JSON.stringify(ideas, null, 2), 'utf-8');
   }
 
   _addIdea(idea) {
@@ -166,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,
@@ -175,6 +190,7 @@ export class LifeEngine {
       lastActivity: this._state.lastActivity,
       lastActivityAgo: lastAgo !== null ? `${lastAgo}m` : 'never',
       lastWakeUpAgo: wakeAgo !== null ? `${wakeAgo}m` : 'never',
+      suppressedActivities,
     };
   }
 
@@ -206,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
@@ -221,6 +259,7 @@ export class LifeEngine {
   // ── Activity Selection ─────────────────────────────────────────
 
   _selectActivity() {
+    const logger = getLogger();
     const lifeConfig = this.config.life || {};
     const selfCodingConfig = lifeConfig.self_coding || {};
     const weights = {
@@ -238,29 +277,44 @@ export class LifeEngine {
     // Rule: don't repeat same type twice in a row
     const last = this._state.lastActivity;
 
-    // Rule: journal cooldown 4h
-    if (this._state.lastJournalTime && now - this._state.lastJournalTime < 4 * 3600_000) {
+    // Cooldown durations (hours) — all configurable via life config, with sensible defaults
+    const journalCooldownMs   = (lifeConfig.cooldown_hours?.journal ?? 4) * 3600_000;
+    const reflectCooldownMs   = (lifeConfig.cooldown_hours?.reflect ?? 4) * 3600_000;
+    const selfCodingEnabled   = selfCodingConfig.enabled === true;
+    const selfCodeCooldownMs  = (selfCodingConfig.cooldown_hours ?? 2) * 3600_000;
+    const codeReviewCooldownMs = (selfCodingConfig.code_review_cooldown_hours ?? 4) * 3600_000;
+
+    // Apply cooldown rules
+    if (this._state.lastJournalTime && now - this._state.lastJournalTime < journalCooldownMs) {
       weights.journal = 0;
     }
 
-    // Rule: self_code cooldown (configurable, default 2h) + must be enabled
-    const selfCodingEnabled = selfCodingConfig.enabled === true;
-    const selfCodeCooldownMs = (selfCodingConfig.cooldown_hours ?? 2) * 3600_000;
     if (!selfCodingEnabled || (this._state.lastSelfCodeTime && now - this._state.lastSelfCodeTime < selfCodeCooldownMs)) {
       weights.self_code = 0;
     }
 
-    // Rule: code_review cooldown (configurable, default 4h) + must have evolution tracker
-    const codeReviewCooldownMs = (selfCodingConfig.code_review_cooldown_hours ?? 4) * 3600_000;
     if (!selfCodingEnabled || !this.evolutionTracker || (this._state.lastCodeReviewTime && now - this._state.lastCodeReviewTime < codeReviewCooldownMs)) {
       weights.code_review = 0;
     }
 
-    // Rule: reflect cooldown 4h
-    if (this._state.lastReflectTime && now - this._state.lastReflectTime < 4 * 3600_000) {
+    if (this._state.lastReflectTime && now - this._state.lastReflectTime < reflectCooldownMs) {
       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];
+        } 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;
@@ -1180,16 +1234,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 = [];
@@ -1218,7 +1307,7 @@ Be honest and constructive. This is your chance to learn from real interactions.
     const logger = getLogger();
     try {
       const response = await this.agent.orchestratorProvider.chat({
-        system: this.agent._getSystemPrompt(LIFE_CHAT_ID, LIFE_USER),
+        system: this.agent._getSystemPrompt(this._lifeChatId, LIFE_USER),
         messages: [{ role: 'user', content: prompt }],
       });
       return response.text || null;
@@ -1238,7 +1327,7 @@ Be honest and constructive. This is your chance to learn from real interactions.
       // Use the agent's processMessage to go through the full orchestrator pipeline
       // The orchestrator will see the task and dispatch appropriately
       const response = await this.agent.processMessage(
-        LIFE_CHAT_ID,
+        this._lifeChatId,
         task,
         LIFE_USER,
         // No-op onUpdate — life engine activities are silent

package/src/life/evolution.js

@@ -18,15 +18,17 @@ const DEFAULT_DATA = {
 };
 
 export class EvolutionTracker {
-  constructor() {
-    mkdirSync(LIFE_DIR, { recursive: true });
+  constructor(basePath = null) {
+    const lifeDir = basePath || LIFE_DIR;
+    this._evolutionFile = join(lifeDir, 'evolution.json');
+    mkdirSync(lifeDir, { recursive: true });
     this._data = this._load();
   }
 
   _load() {
-    if (existsSync(EVOLUTION_FILE)) {
+    if (existsSync(this._evolutionFile)) {
       try {
-        const raw = JSON.parse(readFileSync(EVOLUTION_FILE, 'utf-8'));
+        const raw = JSON.parse(readFileSync(this._evolutionFile, 'utf-8'));
         return {
           proposals: raw.proposals || [],
           lessons: raw.lessons || [],
@@ -40,7 +42,7 @@ export class EvolutionTracker {
   }
 
   _save() {
-    writeFileSync(EVOLUTION_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+    writeFileSync(this._evolutionFile, JSON.stringify(this._data, null, 2), 'utf-8');
   }
 
   _recalcStats() {

package/src/life/journal.js

@@ -20,12 +20,13 @@ function timeNow() {
 }
 
 export class JournalManager {
-  constructor() {
-    mkdirSync(JOURNAL_DIR, { recursive: true });
+  constructor(basePath = null) {
+    this._dir = basePath || JOURNAL_DIR;
+    mkdirSync(this._dir, { recursive: true });
   }
 
   _journalPath(date) {
-    return join(JOURNAL_DIR, `${date}.md`);
+    return join(this._dir, `${date}.md`);
   }
 
   /**
@@ -93,7 +94,7 @@ export class JournalManager {
    */
   list(limit = 30) {
     try {
-      const files = readdirSync(JOURNAL_DIR)
+      const files = readdirSync(this._dir)
         .filter(f => f.endsWith('.md'))
         .map(f => f.replace('.md', ''))
         .sort()

package/src/life/memory.js

@@ -10,17 +10,20 @@ const EPISODIC_DIR = join(LIFE_DIR, 'memories', 'episodic');
 const SEMANTIC_FILE = join(LIFE_DIR, 'memories', 'semantic', 'topics.json');
 
 export class MemoryManager {
-  constructor() {
+  constructor(basePath = null) {
+    const lifeDir = basePath || LIFE_DIR;
+    this._episodicDir = join(lifeDir, 'memories', 'episodic');
+    this._semanticFile = join(lifeDir, 'memories', 'semantic', 'topics.json');
     this._episodicCache = new Map(); // date -> array
     this._semanticCache = null;
-    mkdirSync(EPISODIC_DIR, { recursive: true });
-    mkdirSync(join(LIFE_DIR, 'memories', 'semantic'), { recursive: true });
+    mkdirSync(this._episodicDir, { recursive: true });
+    mkdirSync(join(lifeDir, 'memories', 'semantic'), { recursive: true });
   }
 
   // ── Episodic Memories ──────────────────────────────────────────
 
   _episodicPath(date) {
-    return join(EPISODIC_DIR, `${date}.json`);
+    return join(this._episodicDir, `${date}.json`);
   }
 
   _loadEpisodicDay(date) {
@@ -136,11 +139,11 @@ export class MemoryManager {
     let pruned = 0;
 
     try {
-      const files = readdirSync(EPISODIC_DIR).filter(f => f.endsWith('.json'));
+      const files = readdirSync(this._episodicDir).filter(f => f.endsWith('.json'));
       for (const file of files) {
         const date = file.replace('.json', '');
         if (date < cutoffDate) {
-          unlinkSync(join(EPISODIC_DIR, file));
+          unlinkSync(join(this._episodicDir, file));
           this._episodicCache.delete(date);
           pruned++;
         }
@@ -168,9 +171,9 @@ export class MemoryManager {
 
   _loadSemantic() {
     if (this._semanticCache) return this._semanticCache;
-    if (existsSync(SEMANTIC_FILE)) {
+    if (existsSync(this._semanticFile)) {
       try {
-        this._semanticCache = JSON.parse(readFileSync(SEMANTIC_FILE, 'utf-8'));
+        this._semanticCache = JSON.parse(readFileSync(this._semanticFile, 'utf-8'));
       } catch {
         this._semanticCache = {};
       }
@@ -181,7 +184,7 @@ export class MemoryManager {
   }
 
   _saveSemantic() {
-    writeFileSync(SEMANTIC_FILE, JSON.stringify(this._semanticCache || {}, null, 2), 'utf-8');
+    writeFileSync(this._semanticFile, JSON.stringify(this._semanticCache || {}, null, 2), 'utf-8');
   }
 
   /**

package/src/life/share-queue.js

@@ -9,15 +9,17 @@ const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const SHARES_FILE = join(LIFE_DIR, 'shares.json');
 
 export class ShareQueue {
-  constructor() {
-    mkdirSync(LIFE_DIR, { recursive: true });
+  constructor(basePath = null) {
+    const lifeDir = basePath || LIFE_DIR;
+    this._sharesFile = join(lifeDir, 'shares.json');
+    mkdirSync(lifeDir, { recursive: true });
     this._data = this._load();
   }
 
   _load() {
-    if (existsSync(SHARES_FILE)) {
+    if (existsSync(this._sharesFile)) {
       try {
-        return JSON.parse(readFileSync(SHARES_FILE, 'utf-8'));
+        return JSON.parse(readFileSync(this._sharesFile, 'utf-8'));
       } catch {
         return { pending: [], shared: [] };
       }
@@ -26,7 +28,7 @@ export class ShareQueue {
   }
 
   _save() {
-    writeFileSync(SHARES_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+    writeFileSync(this._sharesFile, JSON.stringify(this._data, null, 2), 'utf-8');
   }
 
   /**