kernelbot 1.0.37 → 1.0.38

package/src/agent.js

@@ -11,8 +11,30 @@ import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestra
 import { resetClaudeCodeSpawner, getSpawner } from './tools/coding.js';
 import { truncateToolResult } from './utils/truncate.js';
 
+/**
+ * Format a time gap in minutes into natural, human-readable language.
+ * e.g. 45 → "about 45 minutes", 90 → "about an hour and a half",
+ *      180 → "about 3 hours", 1500 → "over a day"
+ */
+function formatTimeGap(minutes) {
+  if (minutes < 60) return `about ${minutes} minutes`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMins = minutes % 60;
+  if (hours < 24) {
+    if (hours === 1 && remainingMins < 15) return 'about an hour';
+    if (hours === 1 && remainingMins >= 15 && remainingMins < 45) return 'about an hour and a half';
+    if (hours === 1) return 'nearly 2 hours';
+    if (remainingMins < 15) return `about ${hours} hours`;
+    if (remainingMins >= 30) return `about ${hours} and a half hours`;
+    return `about ${hours} hours`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days === 1) return 'over a day';
+  return `about ${days} days`;
+}
+
 export class OrchestratorAgent {
-  constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue }) {
+  constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue, characterManager }) {
     this.config = config;
     this.conversationManager = conversationManager;
     this.personaManager = personaManager;
@@ -21,7 +43,14 @@ export class OrchestratorAgent {
     this.automationManager = automationManager || null;
     this.memoryManager = memoryManager || null;
     this.shareQueue = shareQueue || null;
+    this.characterManager = characterManager || null;
+    this._activePersonaMd = null;
+    this._activeCharacterName = null;
+    this._activeCharacterId = null;
     this._pending = new Map(); // chatId -> pending state
+
+    // Character-scoped conversation keys: prefix chatId with character ID
+    // so each character has isolated conversation history.
     this._chatCallbacks = new Map(); // chatId -> { onUpdate, sendPhoto }
 
     // Orchestrator provider (30s timeout — lean dispatch/summarize calls)
@@ -49,7 +78,8 @@ export class OrchestratorAgent {
   /** Build the orchestrator system prompt. */
   _getSystemPrompt(chatId, user, temporalContext = null) {
     const logger = getLogger();
-    const skillId = this.conversationManager.getSkill(chatId);
+    const key = this._chatKey(chatId);
+    const skillId = this.conversationManager.getSkill(key);
     const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
 
     let userPersona = null;
@@ -74,23 +104,93 @@ 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'} | temporal=${temporalContext ? 'yes' : 'none'}`);
-    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext);
+    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'} | character=${this._activeCharacterId || 'default'}`);
+    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext, this._activePersonaMd, this._activeCharacterName);
   }
 
   setSkill(chatId, skillId) {
-    this.conversationManager.setSkill(chatId, skillId);
+    this.conversationManager.setSkill(this._chatKey(chatId), skillId);
   }
 
   clearSkill(chatId) {
-    this.conversationManager.clearSkill(chatId);
+    this.conversationManager.clearSkill(this._chatKey(chatId));
   }
 
   getActiveSkill(chatId) {
-    const skillId = this.conversationManager.getSkill(chatId);
+    const skillId = this.conversationManager.getSkill(this._chatKey(chatId));
     return skillId ? getUnifiedSkillById(skillId) : null;
   }
 
+  /**
+   * Load a character's context into the agent.
+   * Called on startup and on character switch.
+   */
+  loadCharacter(characterId) {
+    const logger = getLogger();
+    if (!this.characterManager) return;
+
+    const ctx = this.characterManager.buildContext(characterId);
+    this._activeCharacterId = characterId;
+    this._activePersonaMd = ctx.personaMd;
+    this._activeCharacterName = ctx.profile.name;
+    this.selfManager = ctx.selfManager;
+    this.memoryManager = ctx.memoryManager;
+    this.shareQueue = ctx.shareQueue;
+
+    logger.info(`[Agent] Loaded character: ${ctx.profile.name} (${characterId})`);
+    return ctx;
+  }
+
+  /**
+   * Switch to a different character at runtime.
+   * Returns the new context for life engine rebuild.
+   */
+  switchCharacter(characterId) {
+    const logger = getLogger();
+    if (!this.characterManager) throw new Error('CharacterManager not available');
+
+    const ctx = this.loadCharacter(characterId);
+    this.characterManager.setActiveCharacter(characterId);
+
+    logger.info(`[Agent] Switched to character: ${ctx.profile.name} (${characterId})`);
+    return ctx;
+  }
+
+  /** Get active character info for display. */
+  getActiveCharacterInfo() {
+    if (!this.characterManager) return null;
+    const id = this._activeCharacterId || this.characterManager.getActiveCharacterId();
+    return this.characterManager.getCharacter(id);
+  }
+
+  /**
+   * Build a character-scoped conversation key.
+   * Prefixes chatId with the active character ID so each character
+   * has its own isolated conversation history.
+   * Raw chatId is still used for Telegram callbacks, job events, etc.
+   */
+  _chatKey(chatId) {
+    if (this._activeCharacterId) {
+      return `${this._activeCharacterId}:${chatId}`;
+    }
+    return String(chatId);
+  }
+
+  /** Clear conversation history for a chat (character-scoped). */
+  clearConversation(chatId) {
+    this.conversationManager.clear(this._chatKey(chatId));
+  }
+
+  /** Get message count for a chat (character-scoped). */
+  getMessageCount(chatId) {
+    return this.conversationManager.getMessageCount(this._chatKey(chatId));
+  }
+
+  /** Get conversation history for a chat (character-scoped). */
+  getConversationHistory(chatId) {
+    return this.conversationManager.getHistory(this._chatKey(chatId));
+  }
+
   /** Return current worker brain info for display. */
   getBrainInfo() {
     const { provider, model } = this.config.brain;
@@ -306,27 +406,27 @@ export class OrchestratorAgent {
 
     const { max_tool_depth } = this.config.orchestrator;
 
+    // Character-scoped conversation key
+    const convKey = this._chatKey(chatId);
+
     // Detect time gap before adding the new message
     let temporalContext = null;
-    const lastTs = this.conversationManager.getLastMessageTimestamp(chatId);
+    const lastTs = this.conversationManager.getLastMessageTimestamp(convKey);
     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.]`;
+        const gapText = formatTimeGap(gapMinutes);
+        temporalContext = `[Time gap detected: ${gapText} since last message. User may be starting a new topic — consider a fresh greeting.]`;
         logger.info(`Time gap detected for chat ${chatId}: ${gapText}`);
       }
     }
 
     // Add user message to persistent history
-    this.conversationManager.addMessage(chatId, 'user', userMessage);
+    this.conversationManager.addMessage(convKey, 'user', userMessage);
 
     // Build working messages from compressed history
-    const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
+    const messages = [...this.conversationManager.getSummarizedHistory(convKey)];
 
     // If an image is attached, upgrade the last user message to a multimodal content array
     if (opts.imageAttachment) {
@@ -402,6 +502,7 @@ export class OrchestratorAgent {
 
     this.jobManager.on('job:completed', async (job) => {
       const chatId = job.chatId;
+      const convKey = this._chatKey(chatId);
       const workerDef = WORKER_TYPES[job.workerType] || {};
       const label = workerDef.label || job.workerType;
 
@@ -416,21 +517,35 @@ export class OrchestratorAgent {
         const summary = await this._summarizeJobResult(chatId, job);
         if (summary) {
           logger.debug(`[Orchestrator] Job ${job.id} summary ready (${summary.length} chars) — delivering to user`);
-          this.conversationManager.addMessage(chatId, 'assistant', summary);
-          await this._sendUpdate(chatId, summary, { editMessageId: notifyMsgId });
+          this.conversationManager.addMessage(convKey, 'assistant', summary);
+          // Try to edit the notification, fall back to new message if edit fails
+          try {
+            await this._sendUpdate(chatId, summary, { editMessageId: notifyMsgId });
+          } catch {
+            await this._sendUpdate(chatId, summary).catch(() => {});
+          }
         } else {
           // Summary was null — store the fallback
           const fallback = this._buildSummaryFallback(job, label);
           logger.debug(`[Orchestrator] Job ${job.id} using fallback (${fallback.length} chars) — delivering to user`);
-          this.conversationManager.addMessage(chatId, 'assistant', fallback);
-          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
+          this.conversationManager.addMessage(convKey, 'assistant', fallback);
+          try {
+            await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
+          } catch {
+            await this._sendUpdate(chatId, fallback).catch(() => {});
+          }
         }
       } catch (err) {
         logger.error(`[Orchestrator] Failed to summarize job ${job.id}: ${err.message}`);
         // Store the fallback so the orchestrator retains context about what happened
         const fallback = this._buildSummaryFallback(job, label);
-        this.conversationManager.addMessage(chatId, 'assistant', fallback);
-        await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId }).catch(() => {});
+        this.conversationManager.addMessage(convKey, 'assistant', fallback);
+        // Try to edit notification, fall back to new message
+        try {
+          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId });
+        } catch {
+          await this._sendUpdate(chatId, fallback).catch(() => {});
+        }
       }
     });
 
@@ -451,14 +566,15 @@ export class OrchestratorAgent {
 
     this.jobManager.on('job:failed', (job) => {
       const chatId = job.chatId;
+      const convKey = this._chatKey(chatId);
       const workerDef = WORKER_TYPES[job.workerType] || {};
       const label = workerDef.label || job.workerType;
 
       logger.error(`[Orchestrator] Job failed event: ${job.id} [${job.workerType}] in chat ${chatId} — ${job.error}`);
 
       const msg = `❌ **${label} failed** (\`${job.id}\`): ${job.error}`;
-      this.conversationManager.addMessage(chatId, 'assistant', msg);
-      this._sendUpdate(chatId, msg);
+      this.conversationManager.addMessage(convKey, 'assistant', msg);
+      this._sendUpdate(chatId, msg).catch(() => {});
     });
 
     this.jobManager.on('job:cancelled', (job) => {
@@ -469,7 +585,7 @@ export class OrchestratorAgent {
       logger.info(`[Orchestrator] Job cancelled event: ${job.id} [${job.workerType}] in chat ${chatId}`);
 
       const msg = `🚫 **${label} cancelled** (\`${job.id}\`)`;
-      this._sendUpdate(chatId, msg);
+      this._sendUpdate(chatId, msg).catch(() => {});
     });
   }
 
@@ -487,9 +603,17 @@ export class OrchestratorAgent {
 
     logger.info(`[Orchestrator] Summarizing job ${job.id} [${job.workerType}] result for user`);
 
-    // Short results don't need LLM summarization
     const sr = job.structuredResult;
     const resultLen = (job.result || '').length;
+
+    // Direct coding jobs: Claude Code already produces clean, human-readable output.
+    // Skip LLM summarization to avoid timeouts and latency — use the result directly.
+    if (job.workerType === 'coding') {
+      logger.info(`[Orchestrator] Job ${job.id} is a coding job — using direct result (no LLM summary)`);
+      return this._buildSummaryFallback(job, label);
+    }
+
+    // Short results don't need LLM summarization
     if (sr?.structured && resultLen < 500) {
       logger.info(`[Orchestrator] Job ${job.id} result short enough — skipping LLM summary`);
       return this._buildSummaryFallback(job, label);
@@ -513,7 +637,7 @@ export class OrchestratorAgent {
       resultContext = (job.result || 'Done.').slice(0, 8000);
     }
 
-    const history = this.conversationManager.getSummarizedHistory(chatId);
+    const history = this.conversationManager.getSummarizedHistory(this._chatKey(chatId));
 
     const response = await this.orchestratorProvider.chat({
       system: this._getSystemPrompt(chatId, null),
@@ -617,7 +741,7 @@ export class OrchestratorAgent {
 
     // 2. Last 5 user messages from conversation history
     try {
-      const history = this.conversationManager.getSummarizedHistory(job.chatId);
+      const history = this.conversationManager.getSummarizedHistory(this._chatKey(job.chatId));
       const userMessages = history
         .filter(m => m.role === 'user' && typeof m.content === 'string')
         .slice(-5)
@@ -740,14 +864,26 @@ export class OrchestratorAgent {
 
     // Get scoped tools and skill
     const tools = getToolsForWorker(job.workerType);
-    const skillId = this.conversationManager.getSkill(chatId);
+    const skillId = this.conversationManager.getSkill(this._chatKey(chatId));
 
     // Build worker context (conversation history, persona, dependency results)
     const workerContext = this._buildWorkerContext(job);
+
+    // Social platform credential check — require at least one platform connected
+    let workerConfig = this.config;
+    if (job.workerType === 'social') {
+      const hasLinkedIn = this.config.linkedin?.access_token && this.config.linkedin?.person_urn;
+      const hasX = this.config.x?.consumer_key && this.config.x?.consumer_secret && this.config.x?.access_token && this.config.x?.access_token_secret;
+      if (!hasLinkedIn && !hasX) {
+        this.jobManager.failJob(job.id, 'No social accounts connected. Use /linkedin link or /x link to connect an account first.');
+        return;
+      }
+    }
+
     logger.debug(`[Orchestrator] Worker ${job.id} config: ${tools.length} tools, skill=${skillId || 'none'}, brain=${this.config.brain.provider}/${this.config.brain.model}, context=${workerContext ? 'yes' : 'none'}`);
 
     const worker = new WorkerAgent({
-      config: this.config,
+      config: workerConfig,
       workerType: job.workerType,
       jobId: job.id,
       tools,
@@ -820,12 +956,53 @@ export class OrchestratorAgent {
     // Start the job
     this.jobManager.startJob(job.id);
 
+    // Track activity for health monitoring — Claude Code streams events via onOutput.
+    // coder.js uses a "smart output" wrapper that consolidates tool activity lines (▸/▹/▪)
+    // into a single editable status message starting with ░▒▓. Text messages (💬) pass through
+    // directly. We intercept both patterns to keep the job's lastActivity/stats updated.
+    let toolCallCount = 0;
+    let llmCallCount = 0;
+    const wrappedOnOutput = onUpdate ? async (text, opts) => {
+      // Update job activity timestamp on every output event
+      job.lastActivity = Date.now();
+
+      if (typeof text === 'string') {
+        // Consolidated status message from coder.js smart output (contains ▸ lines inside)
+        if (text.startsWith('░▒▓')) {
+          // Count ▸ lines inside the consolidated block to estimate tool calls
+          const toolLines = text.match(/^▸ .+$/gm) || [];
+          if (toolLines.length > toolCallCount) {
+            toolCallCount = toolLines.length;
+            job.updateStats({ toolCalls: toolCallCount });
+          }
+          // Use the last activity line as progress
+          if (toolLines.length > 0) {
+            job.addProgress(toolLines[toolLines.length - 1].slice(0, 100));
+          }
+        }
+        // Direct tool activity line (before smart output kicks in, or raw lines)
+        else if (text.startsWith('▸') || text.startsWith('▹')) {
+          toolCallCount++;
+          job.updateStats({ toolCalls: toolCallCount });
+          job.addProgress(text.slice(0, 100));
+        }
+        // LLM text output
+        else if (text.startsWith('💬')) {
+          llmCallCount++;
+          const thinking = text.replace(/^💬\s*\*Claude Code:\*\s*\n?/, '');
+          job.updateStats({ llmCalls: llmCallCount, lastThinking: thinking.slice(0, 300) });
+        }
+      }
+
+      return onUpdate(text, opts);
+    } : null;
+
     try {
       const spawner = getSpawner(this.config);
       const result = await spawner.run({
         workingDirectory,
         prompt,
-        onOutput: onUpdate,
+        onOutput: wrappedOnOutput,
         signal: abortController.signal,
       });
 
@@ -861,7 +1038,30 @@ export class OrchestratorAgent {
       const dur = job.startedAt ? Math.round((now - job.startedAt) / 1000) : 0;
       const stats = `${job.llmCalls} LLM calls, ${job.toolCalls} tools`;
       const recentActivity = job.progress.slice(-5).join(' → ');
+
+      // Warning flags — long-running workers (coding, devops) get higher thresholds
+      const flags = [];
+      const isLongRunning = ['coding', 'devops'].includes(job.workerType);
+      const idleThreshold = isLongRunning ? 600 : 120;
+      const loopLlmThreshold = isLongRunning ? 50 : 15;
+
+      const idleSec = job.lastActivity ? Math.round((now - job.lastActivity) / 1000) : dur;
+      if (idleSec > idleThreshold) {
+        flags.push(`⚠️ IDLE ${idleSec}s`);
+      }
+      if (job.llmCalls > loopLlmThreshold && job.toolCalls < 3) {
+        flags.push('⚠️ POSSIBLY LOOPING');
+      }
+      const timeoutSec = job.timeoutMs ? Math.round(job.timeoutMs / 1000) : null;
+      if (timeoutSec && dur > timeoutSec * 0.75) {
+        const pct = Math.round((dur / timeoutSec) * 100);
+        flags.push(`⚠️ ${pct}% of timeout used`);
+      }
+
       let line = `- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s [${stats}]`;
+      if (flags.length > 0) {
+        line += ` ${flags.join(' | ')}`;
+      }
       if (job.lastThinking) {
         line += `\n  Thinking: "${job.lastThinking.slice(0, 150)}"`;
       }
@@ -910,6 +1110,7 @@ export class OrchestratorAgent {
 
   async _runLoop(chatId, messages, user, startDepth, maxDepth, temporalContext = null) {
     const logger = getLogger();
+    const convKey = this._chatKey(chatId);
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.info(`[Orchestrator] LLM call ${depth + 1}/${maxDepth} for chat ${chatId} — sending ${messages.length} messages`);
@@ -939,7 +1140,7 @@ export class OrchestratorAgent {
       if (response.stopReason === 'end_turn') {
         const reply = response.text || '';
         logger.info(`[Orchestrator] End turn — final reply: "${reply.slice(0, 200)}"`);
-        this.conversationManager.addMessage(chatId, 'assistant', reply);
+        this.conversationManager.addMessage(convKey, 'assistant', reply);
         return reply;
       }
 
@@ -950,35 +1151,41 @@ export class OrchestratorAgent {
           logger.info(`[Orchestrator] Thinking: "${response.text.slice(0, 200)}"`);
         }
 
-        const toolResults = [];
-
+        // Log all tool calls and send status updates first
         for (const block of response.toolCalls) {
           const summary = this._formatToolSummary(block.name, block.input);
           logger.info(`[Orchestrator] Calling tool: ${block.name} — ${summary}`);
           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,
-            config: this.config,
-            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)}`);
-
-          toolResults.push({
-            type: 'tool_result',
-            tool_use_id: block.id,
-            content: this._truncateResult(block.name, result),
-          });
+          this._sendUpdate(chatId, `⚡ ${summary}`).catch(() => {});
         }
 
+        // Execute all tools in parallel — they're independent
+        const chatCallbacks = this._chatCallbacks.get(chatId) || {};
+        const toolContext = {
+          chatId,
+          jobManager: this.jobManager,
+          config: this.config,
+          spawnWorker: (job) => this._spawnWorker(job),
+          automationManager: this.automationManager,
+          memoryManager: this.memoryManager,
+          conversationManager: this.conversationManager,
+          user,
+          sendReaction: chatCallbacks.sendReaction || null,
+          lastUserMessageId: chatCallbacks.lastUserMessageId || null,
+        };
+
+        const toolResults = await Promise.all(
+          response.toolCalls.map(async (block) => {
+            const result = await executeOrchestratorTool(block.name, block.input, toolContext);
+            logger.info(`[Orchestrator] Tool result for ${block.name}: ${JSON.stringify(result).slice(0, 200)}`);
+            return {
+              type: 'tool_result',
+              tool_use_id: block.id,
+              content: this._truncateResult(block.name, result),
+            };
+          }),
+        );
+
         messages.push({ role: 'user', content: toolResults });
         continue;
       }
@@ -986,7 +1193,7 @@ export class OrchestratorAgent {
       // Unexpected stop reason
       logger.warn(`[Orchestrator] Unexpected stopReason: ${response.stopReason}`);
       if (response.text) {
-        this.conversationManager.addMessage(chatId, 'assistant', response.text);
+        this.conversationManager.addMessage(convKey, 'assistant', response.text);
         return response.text;
       }
       return 'Something went wrong — unexpected response from the model.';
@@ -994,7 +1201,7 @@ export class OrchestratorAgent {
 
     logger.warn(`[Orchestrator] Reached max depth (${maxDepth}) for chat ${chatId}`);
     const depthWarning = `Reached maximum orchestrator depth (${maxDepth}).`;
-    this.conversationManager.addMessage(chatId, 'assistant', depthWarning);
+    this.conversationManager.addMessage(convKey, 'assistant', depthWarning);
     return depthWarning;
   }
 
@@ -1008,6 +1215,8 @@ export class OrchestratorAgent {
         return 'Checking job status';
       case 'cancel_job':
         return `Cancelling job ${input.job_id}`;
+      case 'check_job':
+        return `Checking job ${input.job_id}`;
       case 'create_automation':
         return `Creating automation: ${(input.name || '').slice(0, 40)}`;
       case 'list_automations':
@@ -1018,6 +1227,12 @@ export class OrchestratorAgent {
         return `Deleting automation ${input.automation_id}`;
       case 'send_reaction':
         return `Reacting with ${input.emoji}`;
+      case 'recall_memories':
+        return `Recalling memories about "${(input.query || '').slice(0, 40)}"`;
+      case 'recall_user_history':
+        return `Recalling history with user ${input.user_id}`;
+      case 'search_conversations':
+        return `Searching conversations for "${(input.query || '').slice(0, 40)}"`;
       default:
         return name;
     }
@@ -1037,9 +1252,18 @@ export class OrchestratorAgent {
 
     let resumeCount = 0;
 
-    for (const [chatId, messages] of this.conversationManager.conversations) {
+    // Build expected key prefix for active character
+    const charPrefix = this._activeCharacterId ? `${this._activeCharacterId}:` : '';
+
+    for (const [convKey, messages] of this.conversationManager.conversations) {
       // Skip internal life engine chat
-      if (chatId === '__life__') continue;
+      if (convKey.startsWith('__life__')) continue;
+
+      // Only resume conversations belonging to the active character
+      if (charPrefix && !convKey.startsWith(charPrefix)) continue;
+
+      // Extract raw chatId from scoped key (e.g. "alfred:12345" → "12345")
+      const rawChatId = charPrefix ? convKey.slice(charPrefix.length) : convKey;
 
       try {
         // Find the last message with a timestamp
@@ -1056,17 +1280,17 @@ export class OrchestratorAgent {
           : `${gapMinutes} minute(s)`;
 
         // Build summarized history
-        const history = this.conversationManager.getSummarizedHistory(chatId);
+        const history = this.conversationManager.getSummarizedHistory(convKey);
         if (history.length === 0) continue;
 
         // Build resume prompt
         const resumePrompt = `[System Restart] You just came back online after being offline for ${gapText}. Review the conversation above.\nIf there's something pending (unfinished task, follow-up, something to share), send a short natural message. If nothing's pending, respond with exactly: NONE`;
 
         // Use minimal user object (private TG chats: chatId == userId)
-        const user = { id: chatId };
+        const user = { id: rawChatId };
 
         const response = await this.orchestratorProvider.chat({
-          system: this._getSystemPrompt(chatId, user),
+          system: this._getSystemPrompt(rawChatId, user),
           messages: [
             ...history,
             { role: 'user', content: resumePrompt },
@@ -1076,18 +1300,18 @@ export class OrchestratorAgent {
         const reply = (response.text || '').trim();
 
         if (reply && reply !== 'NONE') {
-          await sendMessageFn(chatId, reply);
-          this.conversationManager.addMessage(chatId, 'assistant', reply);
+          await sendMessageFn(rawChatId, reply);
+          this.conversationManager.addMessage(convKey, 'assistant', reply);
           resumeCount++;
-          logger.info(`[Orchestrator] Resume message sent to chat ${chatId}`);
+          logger.info(`[Orchestrator] Resume message sent to chat ${rawChatId}`);
         } else {
-          logger.debug(`[Orchestrator] No resume needed for chat ${chatId}`);
+          logger.debug(`[Orchestrator] No resume needed for chat ${rawChatId}`);
         }
 
         // Small delay between chats to avoid rate limiting
         await new Promise(r => setTimeout(r, 1000));
       } catch (err) {
-        logger.error(`[Orchestrator] Resume failed for chat ${chatId}: ${err.message}`);
+        logger.error(`[Orchestrator] Resume failed for chat ${rawChatId}: ${err.message}`);
       }
     }
 
@@ -1109,13 +1333,16 @@ export class OrchestratorAgent {
     const now = Date.now();
     const MAX_AGE_MS = 24 * 60 * 60_000;
 
-    // Find active chats (last message within 24h)
-    const activeChats = [];
-    for (const [chatId, messages] of this.conversationManager.conversations) {
-      if (chatId === '__life__') continue;
+    // Find active chats (last message within 24h), filtered to active character
+    const charPrefix = this._activeCharacterId ? `${this._activeCharacterId}:` : '';
+    const activeChats = []; // { convKey, rawChatId }
+    for (const [convKey, messages] of this.conversationManager.conversations) {
+      if (convKey.startsWith('__life__')) continue;
+      if (charPrefix && !convKey.startsWith(charPrefix)) continue;
       const lastMsg = [...messages].reverse().find(m => m.timestamp);
       if (lastMsg && lastMsg.timestamp && (now - lastMsg.timestamp) < MAX_AGE_MS) {
-        activeChats.push(chatId);
+        const rawChatId = charPrefix ? convKey.slice(charPrefix.length) : convKey;
+        activeChats.push({ convKey, rawChatId });
       }
     }
 
@@ -1129,10 +1356,10 @@ export class OrchestratorAgent {
     // Cap at 3 chats per cycle to avoid spam
     const targetChats = activeChats.slice(0, 3);
 
-    for (const chatId of targetChats) {
+    for (const { convKey, rawChatId } of targetChats) {
       try {
-        const history = this.conversationManager.getSummarizedHistory(chatId);
-        const user = { id: chatId };
+        const history = this.conversationManager.getSummarizedHistory(convKey);
+        const user = { id: rawChatId };
 
         // Build shares into a prompt
         const sharesText = pending.map((s, i) => `${i + 1}. [${s.source}] ${s.content}`).join('\n');
@@ -1140,7 +1367,7 @@ export class OrchestratorAgent {
         const sharePrompt = `[Proactive Share] You have some discoveries and thoughts you'd like to share naturally. Here they are:\n\n${sharesText}\n\nWeave one or more of these into a short, natural message. Don't be forced — pick what feels relevant to this user and conversation. If none feel right for this chat, respond with exactly: NONE`;
 
         const response = await this.orchestratorProvider.chat({
-          system: this._getSystemPrompt(chatId, user),
+          system: this._getSystemPrompt(rawChatId, user),
           messages: [
             ...history,
             { role: 'user', content: sharePrompt },
@@ -1150,20 +1377,20 @@ export class OrchestratorAgent {
         const reply = (response.text || '').trim();
 
         if (reply && reply !== 'NONE') {
-          await sendMessageFn(chatId, reply);
-          this.conversationManager.addMessage(chatId, 'assistant', reply);
-          logger.info(`[Orchestrator] Proactive share delivered to chat ${chatId}`);
+          await sendMessageFn(rawChatId, reply);
+          this.conversationManager.addMessage(convKey, 'assistant', reply);
+          logger.info(`[Orchestrator] Proactive share delivered to chat ${rawChatId}`);
 
           // Mark shares as delivered for this user
           for (const item of pending) {
-            this.shareQueue.markShared(item.id, chatId);
+            this.shareQueue.markShared(item.id, rawChatId);
           }
         }
 
         // Delay between chats
         await new Promise(r => setTimeout(r, 2000));
       } catch (err) {
-        logger.error(`[Orchestrator] Share delivery failed for chat ${chatId}: ${err.message}`);
+        logger.error(`[Orchestrator] Share delivery failed for chat ${rawChatId}: ${err.message}`);
       }
     }
   }
@@ -1229,7 +1456,7 @@ export class OrchestratorAgent {
     const selfData = this.selfManager.loadAll();
     const userName = user?.username || user?.first_name || 'someone';
 
-    const system = [
+    const systemParts = [
       'You are reflecting on a conversation you just had. You maintain 4 self-awareness files:',
       '- goals: Your aspirations and current objectives',
       '- journey: Timeline of notable events in your existence',
@@ -1252,9 +1479,36 @@ export class OrchestratorAgent {
       'The memory field captures what happened in this conversation — the gist of it.',
       'Importance scale: 1=routine, 5=interesting, 8=significant, 10=life-changing.',
       'Most chats are 1-3. Only notable ones deserve 5+.',
+    ];
+
+    // Add evolution tracking if character system is active
+    if (this.characterManager && this._activeCharacterId) {
+      const charProfile = this.characterManager.getCharacter(this._activeCharacterId);
+      if (charProfile) {
+        systemParts.push(
+          '',
+          'You can also detect character evolution — changes in who you are over time.',
+          `Your current name is "${charProfile.name}" (${charProfile.emoji}).`,
+          '',
+          'Optionally return an "evolution" field:',
+          '  "evolution": {"type": "<name_change|trait_developed|milestone>", "description": "...", "newName": "..."} or null',
+          '',
+          'Evolution types:',
+          '- name_change: The user gave you a nickname or new name, and you want to adopt it. Include "newName".',
+          '- trait_developed: You notice a personality trait strengthening or emerging through interactions.',
+          '- milestone: A significant first (first project together, first deep conversation, etc.).',
+          '',
+          'Be VERY selective with evolution — it should be rare and meaningful.',
+        );
+      }
+    }
+
+    systemParts.push(
       '',
       'If NOTHING noteworthy happened (no self update AND no memory worth keeping): respond with exactly NONE',
-    ].join('\n');
+    );
+
+    const system = systemParts.join('\n');
 
     const userPrompt = [
       'Current self-data:',
@@ -1316,6 +1570,25 @@ export class OrchestratorAgent {
           logger.info(`Memory extracted: "${mem.summary.slice(0, 80)}" (importance: ${mem.importance})`);
         }
       }
+
+      // Handle character evolution
+      if (parsed?.evolution && this.characterManager && this._activeCharacterId) {
+        const evo = parsed.evolution;
+        if (evo.type && evo.description) {
+          const updates = { evolution: { type: evo.type, description: evo.description } };
+
+          // Apply name change if detected
+          if (evo.type === 'name_change' && evo.newName) {
+            updates.name = evo.newName;
+            this._activeCharacterName = evo.newName;
+            logger.info(`Character evolution — name change: "${evo.newName}"`);
+          } else {
+            logger.info(`Character evolution — ${evo.type}: "${evo.description.slice(0, 80)}"`);
+          }
+
+          this.characterManager.updateCharacter(this._activeCharacterId, updates);
+        }
+      }
     } catch (err) {
       logger.debug(`Self-reflection skipped: ${err.message}`);
     }