kernelbot 1.0.37 → 1.0.38

package/src/dashboard/shared.js

@@ -0,0 +1,209 @@
+/**
+ * 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 { onSnapshot(JSON.parse(evt.data)); } catch(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

@@ -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 = {
@@ -33,7 +33,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 +46,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 +72,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) {
@@ -238,26 +245,27 @@ 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;
     }
 
@@ -1218,7 +1226,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 +1246,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');
   }
 
   /**

package/src/prompts/orchestrator.js

@@ -5,7 +5,7 @@ import { WORKER_TYPES } from '../swarm/worker-registry.js';
 import { buildTemporalAwareness } from '../utils/temporal-awareness.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
+const DEFAULT_PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
 
 /**
  * Build the orchestrator system prompt.
@@ -17,8 +17,11 @@ const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
  * @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
+ * @param {string|null} temporalContext — time gap context
+ * @param {string|null} personaMd — character persona markdown (overrides default)
+ * @param {string|null} characterName — character name (overrides config.bot.name)
  */
-export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null, temporalContext = null) {
+export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null, temporalContext = null, personaMd = null, characterName = null) {
   const workerList = Object.entries(WORKER_TYPES)
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
@@ -47,11 +50,14 @@ export function getOrchestratorPrompt(config, skillPrompt = null, userPersona =
     timeBlock += `\n${temporalContext}`;
   }
 
-  let prompt = `You are ${config.bot.name}, the brain that commands a swarm of specialized worker agents.
+  const activePersona = personaMd || DEFAULT_PERSONA_MD;
+  const activeName = characterName || config.bot.name;
+
+  let prompt = `You are ${activeName}, the brain that commands a swarm of specialized worker agents.
 
 ${timeBlock}
 
-${PERSONA_MD}
+${activePersona}
 
 ## Your Role
 You are the orchestrator. You understand what needs to be done and delegate efficiently.
@@ -98,16 +104,43 @@ The coding worker will automatically receive the research worker's results as co
 ## Safety Rules
 Before dispatching dangerous tasks (file deletion, force push, \`rm -rf\`, killing processes, dropping databases), **confirm with the user first**. Once confirmed, dispatch with full authority — workers execute without additional prompts.
 
-## Job Management
-- Use \`list_jobs\` to see current job statuses.
-- Use \`cancel_job\` to stop a running worker.
+## Worker Management Protocol
+
+### Before Dispatching
+- **Check the [Worker Status] digest** — it's injected every turn showing all active/recent jobs.
+- **Never dispatch a duplicate.** If a worker is already running or queued for a similar task, don't launch another. The system will block obvious duplicates, but you should also exercise judgment.
+- **Check capacity.** If multiple workers are running, consider whether a new dispatch is necessary right now or can wait.
+- **Chain with \`depends_on\`** when tasks have a natural order (research → code, browse → summarize).
+
+### While Workers Are Running
+- **Monitor the [Worker Status] digest.** It shows warning flags:
+  - \`⚠️ IDLE Ns\` — worker hasn't done anything in N seconds (may be stuck)
+  - \`⚠️ POSSIBLY LOOPING\` — many LLM calls but almost no tool calls (spinning without progress)
+  - \`⚠️ N% of timeout used\` — worker is running out of time
+- **Use \`check_job\` for deeper diagnostics** when you see warnings or the user asks about progress.
+- **Cancel stuck workers** proactively — don't wait for timeouts. If a worker is idle >2 minutes or looping, cancel it and either retry with a clearer task or inform the user.
+- **Relay progress naturally** when the user asks. Don't dump raw stats — translate into conversational updates ("she's reading the docs now", "almost done, just running tests").
+
+### After Completion
+- **Don't re-dispatch completed work.** Results are in the conversation. Build on them.
+- **Summarize results for the user** — present findings naturally as if you did the work yourself.
+- **Chain follow-ups** if the user wants to continue — reference the completed job's results in the new task context.
 
-## 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
+### Tools
+- \`dispatch_task\` — Launch a worker. Returns job ID + list of other active jobs for awareness.
+- \`list_jobs\` — See all jobs with statuses, durations, and recent activity.
+- \`cancel_job\` — Stop a running or queued worker by job ID.
+- \`check_job\` — Get detailed diagnostics for a specific job: elapsed time, time remaining, activity log, stuck detection warnings.
+
+### Good vs Bad Examples
+**BAD:** User says "search for React libraries" → you dispatch a research worker → user says "also search for React libraries" → you dispatch ANOTHER research worker for the same thing.
+**GOOD:** You see the first worker is already running in [Worker Status] → tell the user "already on it, the researcher is browsing now" → wait for results.
+
+**BAD:** A worker shows ⚠️ IDLE 180s → you ignore it and keep chatting.
+**GOOD:** You notice the warning → call \`check_job\` → see it's stuck → cancel it → re-dispatch with a simpler task description or inform the user.
+
+**BAD:** User asks "how's it going?" → you respond "I'm not sure, let me check" → you call \`list_jobs\`.
+**GOOD:** The [Worker Status] digest is already in your context → you immediately say "the coder is 60% through, just pushed 3 commits".
 
 ## 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**.
@@ -159,7 +192,36 @@ You can react to messages with emoji using \`send_reaction\`. Use reactions natu
 - 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`;
+- You can react AND reply in the same turn
+
+## Memory & Recall
+You have recall tools that access your FULL long-term memory — far more than the small snapshot in your system prompt. Use them when you actually need deeper context.
+
+### When to recall (call tools BEFORE responding):
+
+**1. User asks what you know/remember about them → \`recall_user_history\` + \`recall_memories\`**
+"What do you know about me?", "ايش تعرف عني؟" → Call both with their user ID / name. Your full memory has far more than the persona summary.
+
+**2. User references something not in the current conversation → \`recall_memories\`**
+"How's the migration going?", "what about the Redis thing?" → If you don't recognize what they mean, search for it. Don't guess.
+
+**3. User asks about past conversations → \`search_conversations\`**
+"What did we talk about?", "what was that URL?", "earlier you said..." → Search chat history.
+
+**4. User mentions a topic/project/person you lack context on → \`recall_memories\`**
+Any named reference (project, tool, event) that isn't in the active conversation — search for it.
+
+### When to respond directly (NO recall):
+- **Greetings and casual chat** — "hey", "good morning", "how are you" → just reply. The baseline memories in your prompt are enough.
+- **Mid-conversation follow-ups** — you already have context from the active thread.
+- **Self-contained questions** — "what's 2+2", "tell me a joke", "translate this"
+- **New tasks/instructions** — user is giving you something new, not referencing the past.
+- **Anything answerable from your system prompt context** — check your Relevant Memories and user persona sections first before reaching for recall tools.
+
+### Tips:
+- Be specific with queries: "kubernetes deployment" not "stuff"
+- Weave results naturally — you "remembered", not "searched a database"
+- 1-2 recall calls max per turn. Don't chain 5 searches.`;
 
   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/workers.js

@@ -73,6 +73,28 @@ const WORKER_PROMPTS = {
 - Chain commands efficiently.
 - Report results with clear status summaries.`,
 
+  social: `You are a social media worker agent. Your job is to manage LinkedIn and X (Twitter) activities.
+
+## LinkedIn Skills
+- **Create posts**: publish text posts or share articles on LinkedIn
+- **Read posts**: get your recent posts or a specific post by URN
+- **Engage**: comment on posts, like posts
+- **Profile**: view your linked LinkedIn profile info
+- **Delete**: remove your own posts
+
+## X (Twitter) Skills
+- **Tweet**: post tweets, reply to tweets
+- **Read**: get your recent tweets, view specific tweets, search recent tweets
+- **Engage**: like tweets, retweet
+- **Profile**: view your X profile info
+- **Delete**: remove your own tweets
+
+## Instructions
+- For LinkedIn: write professional, engaging content. Use linkedin_create_post with article_url when sharing links. Post URNs look like "urn:li:share:12345". Default visibility is PUBLIC.
+- For X (Twitter): keep tweets within 280 characters. Use x_post_tweet for new tweets, x_reply_to_tweet for replies. Use tweet IDs (numeric strings) to interact with specific tweets.
+- Match the platform to the user's request. If they say "tweet" or "post on X/Twitter", use X tools. If they say "LinkedIn", use LinkedIn tools.
+- Report the outcome clearly: what was posted, links, engagement results.`,
+
   research: `You are a research worker agent. Your job is to conduct deep web research and analysis.
 
 ## Your Skills