kernelbot 1.0.26 → 1.0.30

package/src/agent.js

@@ -1,23 +1,85 @@
 import { createProvider, PROVIDERS } from './providers/index.js';
-import { toolDefinitions, executeTool, checkConfirmation } from './tools/index.js';
-import { selectToolsForMessage, expandToolsForUsed } from './tools/categories.js';
-import { getSystemPrompt } from './prompts/system.js';
+import { orchestratorToolDefinitions, executeOrchestratorTool } from './tools/orchestrator-tools.js';
+import { getToolsForWorker } from './swarm/worker-registry.js';
+import { WORKER_TYPES } from './swarm/worker-registry.js';
+import { getOrchestratorPrompt } from './prompts/orchestrator.js';
+import { getWorkerPrompt } from './prompts/workers.js';
+import { getUnifiedSkillById } from './skills/custom.js';
+import { WorkerAgent } from './worker.js';
 import { getLogger } from './utils/logger.js';
-import { getMissingCredential, saveCredential, saveProviderToYaml } from './utils/config.js';
+import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestratorToYaml, saveClaudeCodeModelToYaml, saveClaudeCodeAuth } from './utils/config.js';
+import { resetClaudeCodeSpawner } from './tools/coding.js';
 
 const MAX_RESULT_LENGTH = 3000;
 const LARGE_FIELDS = ['stdout', 'stderr', 'content', 'diff', 'output', 'body', 'html', 'text', 'log', 'logs'];
 
-export class Agent {
-  constructor({ config, conversationManager }) {
+export class OrchestratorAgent {
+  constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager }) {
     this.config = config;
     this.conversationManager = conversationManager;
-    this.provider = createProvider(config);
-    this.systemPrompt = getSystemPrompt(config);
+    this.personaManager = personaManager;
+    this.selfManager = selfManager || null;
+    this.jobManager = jobManager;
+    this.automationManager = automationManager || null;
     this._pending = new Map(); // chatId -> pending state
+    this._chatCallbacks = new Map(); // chatId -> { onUpdate, sendPhoto }
+
+    // Orchestrator provider (30s timeout — lean dispatch/summarize calls)
+    const orchProviderKey = config.orchestrator.provider || 'anthropic';
+    const orchProviderDef = PROVIDERS[orchProviderKey];
+    const orchApiKey = config.orchestrator.api_key || (orchProviderDef && process.env[orchProviderDef.envKey]) || process.env.ANTHROPIC_API_KEY;
+    this.orchestratorProvider = createProvider({
+      brain: {
+        provider: orchProviderKey,
+        model: config.orchestrator.model,
+        max_tokens: config.orchestrator.max_tokens,
+        temperature: config.orchestrator.temperature,
+        api_key: orchApiKey,
+        timeout: 30_000,
+      },
+    });
+
+    // Worker provider uses user's chosen brain
+    this.workerProvider = createProvider(config);
+
+    // Set up job lifecycle event listeners
+    this._setupJobListeners();
+  }
+
+  /** Build the orchestrator system prompt. */
+  _getSystemPrompt(chatId, user) {
+    const logger = getLogger();
+    const skillId = this.conversationManager.getSkill(chatId);
+    const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
+
+    let userPersona = null;
+    if (this.personaManager && user?.id) {
+      userPersona = this.personaManager.load(user.id, user.username);
+    }
+
+    let selfData = null;
+    if (this.selfManager) {
+      selfData = this.selfManager.loadAll();
+    }
+
+    logger.debug(`Orchestrator building system prompt for chat ${chatId} | skill=${skillId || 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'}`);
+    return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData);
   }
 
-  /** Return current brain info for display. */
+  setSkill(chatId, skillId) {
+    this.conversationManager.setSkill(chatId, skillId);
+  }
+
+  clearSkill(chatId) {
+    this.conversationManager.clearSkill(chatId);
+  }
+
+  getActiveSkill(chatId) {
+    const skillId = this.conversationManager.getSkill(chatId);
+    return skillId ? getUnifiedSkillById(skillId) : null;
+  }
+
+  /** Return current worker brain info for display. */
   getBrainInfo() {
     const { provider, model } = this.config.brain;
     const providerDef = PROVIDERS[provider];
@@ -27,64 +89,190 @@ export class Agent {
     return { provider, providerName, model, modelLabel };
   }
 
-  /**
-   * Switch to a different provider/model at runtime.
-   * Resolves the API key from process.env automatically.
-   * Returns null on success, or an error string if the key is missing.
-   */
-  switchBrain(providerKey, modelId) {
+  /** Return current orchestrator info for display. */
+  getOrchestratorInfo() {
+    const provider = this.config.orchestrator.provider || 'anthropic';
+    const model = this.config.orchestrator.model;
+    const providerDef = PROVIDERS[provider];
+    const providerName = providerDef ? providerDef.name : provider;
+    const modelEntry = providerDef?.models.find((m) => m.id === model);
+    const modelLabel = modelEntry ? modelEntry.label : model;
+    return { provider, providerName, model, modelLabel };
+  }
+
+  /** Switch orchestrator provider/model at runtime. */
+  async switchOrchestrator(providerKey, modelId) {
     const logger = getLogger();
     const providerDef = PROVIDERS[providerKey];
     if (!providerDef) return `Unknown provider: ${providerKey}`;
 
     const envKey = providerDef.envKey;
     const apiKey = process.env[envKey];
-    if (!apiKey) {
-      return envKey; // caller handles prompting
+    if (!apiKey) return envKey;
+
+    try {
+      const testProvider = createProvider({
+        brain: {
+          provider: providerKey,
+          model: modelId,
+          max_tokens: this.config.orchestrator.max_tokens,
+          temperature: this.config.orchestrator.temperature,
+          api_key: apiKey,
+          timeout: 30_000,
+        },
+      });
+      await testProvider.ping();
+
+      this.config.orchestrator.provider = providerKey;
+      this.config.orchestrator.model = modelId;
+      this.config.orchestrator.api_key = apiKey;
+      this.orchestratorProvider = testProvider;
+      saveOrchestratorToYaml(providerKey, modelId);
+
+      logger.info(`Orchestrator switched to ${providerDef.name} / ${modelId}`);
+      return null;
+    } catch (err) {
+      logger.error(`Orchestrator switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);
+      return { error: err.message };
+    }
+  }
+
+  /** Finalize orchestrator switch after API key was provided via chat. */
+  async switchOrchestratorWithKey(providerKey, modelId, apiKey) {
+    const logger = getLogger();
+    const providerDef = PROVIDERS[providerKey];
+
+    try {
+      const testProvider = createProvider({
+        brain: {
+          provider: providerKey,
+          model: modelId,
+          max_tokens: this.config.orchestrator.max_tokens,
+          temperature: this.config.orchestrator.temperature,
+          api_key: apiKey,
+          timeout: 30_000,
+        },
+      });
+      await testProvider.ping();
+
+      saveCredential(this.config, providerDef.envKey, apiKey);
+      this.config.orchestrator.provider = providerKey;
+      this.config.orchestrator.model = modelId;
+      this.config.orchestrator.api_key = apiKey;
+      this.orchestratorProvider = testProvider;
+      saveOrchestratorToYaml(providerKey, modelId);
+
+      logger.info(`Orchestrator switched to ${providerDef.name} / ${modelId} (new key saved)`);
+      return null;
+    } catch (err) {
+      logger.error(`Orchestrator switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);
+      return { error: err.message };
     }
+  }
 
-    this.config.brain.provider = providerKey;
-    this.config.brain.model = modelId;
-    this.config.brain.api_key = apiKey;
+  /** Return current Claude Code model info for display. */
+  getClaudeCodeInfo() {
+    const model = this.config.claude_code?.model || 'claude-opus-4-6';
+    const providerDef = PROVIDERS.anthropic;
+    const modelEntry = providerDef?.models.find((m) => m.id === model);
+    const modelLabel = modelEntry ? modelEntry.label : model;
+    return { model, modelLabel };
+  }
 
-    // Recreate the provider instance
-    this.provider = createProvider(this.config);
+  /** Switch Claude Code model at runtime. */
+  switchClaudeCodeModel(modelId) {
+    const logger = getLogger();
+    this.config.claude_code.model = modelId;
+    saveClaudeCodeModelToYaml(modelId);
+    resetClaudeCodeSpawner();
+    logger.info(`Claude Code model switched to ${modelId}`);
+  }
 
-    // Persist to config.yaml
-    saveProviderToYaml(providerKey, modelId);
+  /** Return current Claude Code auth config for display. */
+  getClaudeAuthConfig() {
+    const mode = this.config.claude_code?.auth_mode || 'system';
+    const info = { mode };
+
+    if (mode === 'api_key') {
+      const key = this.config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY || '';
+      info.credential = key ? `${key.slice(0, 8)}...${key.slice(-4)}` : '(not set)';
+    } else if (mode === 'oauth_token') {
+      const token = this.config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN || '';
+      info.credential = token ? `${token.slice(0, 8)}...${token.slice(-4)}` : '(not set)';
+    } else {
+      info.credential = 'Using host system login';
+    }
 
-    logger.info(`Brain switched to ${providerDef.name} / ${modelId}`);
-    return null;
+    return info;
   }
 
-  /**
-   * Finalize brain switch after API key was provided via chat.
-   */
-  switchBrainWithKey(providerKey, modelId, apiKey) {
+  /** Set Claude Code auth mode + credential at runtime. */
+  setClaudeCodeAuth(mode, value) {
     const logger = getLogger();
-    const providerDef = PROVIDERS[providerKey];
+    saveClaudeCodeAuth(this.config, mode, value);
+    resetClaudeCodeSpawner();
+    logger.info(`Claude Code auth mode set to: ${mode}`);
+  }
 
-    // Save the key
-    saveCredential(this.config, providerDef.envKey, apiKey);
+  /** Switch worker brain provider/model at runtime. */
+  async switchBrain(providerKey, modelId) {
+    const logger = getLogger();
+    const providerDef = PROVIDERS[providerKey];
+    if (!providerDef) return `Unknown provider: ${providerKey}`;
 
-    this.config.brain.provider = providerKey;
-    this.config.brain.model = modelId;
-    this.config.brain.api_key = apiKey;
+    const envKey = providerDef.envKey;
+    const apiKey = process.env[envKey];
+    if (!apiKey) return envKey;
+
+    try {
+      const testConfig = { ...this.config, brain: { ...this.config.brain, provider: providerKey, model: modelId, api_key: apiKey } };
+      const testProvider = createProvider(testConfig);
+      await testProvider.ping();
+
+      this.config.brain.provider = providerKey;
+      this.config.brain.model = modelId;
+      this.config.brain.api_key = apiKey;
+      this.workerProvider = testProvider;
+      saveProviderToYaml(providerKey, modelId);
+
+      logger.info(`Worker brain switched to ${providerDef.name} / ${modelId}`);
+      return null;
+    } catch (err) {
+      logger.error(`Brain switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);
+      return { error: err.message };
+    }
+  }
 
-    this.provider = createProvider(this.config);
-    saveProviderToYaml(providerKey, modelId);
+  /** Finalize brain switch after API key was provided via chat. */
+  async switchBrainWithKey(providerKey, modelId, apiKey) {
+    const logger = getLogger();
+    const providerDef = PROVIDERS[providerKey];
 
-    logger.info(`Brain switched to ${providerDef.name} / ${modelId} (new key saved)`);
+    try {
+      const testConfig = { ...this.config, brain: { ...this.config.brain, provider: providerKey, model: modelId, api_key: apiKey } };
+      const testProvider = createProvider(testConfig);
+      await testProvider.ping();
+
+      saveCredential(this.config, providerDef.envKey, apiKey);
+      this.config.brain.provider = providerKey;
+      this.config.brain.model = modelId;
+      this.config.brain.api_key = apiKey;
+      this.workerProvider = testProvider;
+      saveProviderToYaml(providerKey, modelId);
+
+      logger.info(`Worker brain switched to ${providerDef.name} / ${modelId} (new key saved)`);
+      return null;
+    } catch (err) {
+      logger.error(`Brain switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);
+      return { error: err.message };
+    }
   }
 
-  /**
-   * Truncate a tool result to stay within token budget.
-   */
+  /** Truncate a tool result. */
   _truncateResult(name, result) {
     let str = JSON.stringify(result);
     if (str.length <= MAX_RESULT_LENGTH) return str;
 
-    // Try truncating known large fields first
     if (result && typeof result === 'object') {
       const truncated = { ...result };
       for (const field of LARGE_FIELDS) {
@@ -96,217 +284,524 @@ export class Agent {
       if (str.length <= MAX_RESULT_LENGTH) return str;
     }
 
-    // Hard truncate
     return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
   }
 
   async processMessage(chatId, userMessage, user, onUpdate, sendPhoto) {
     const logger = getLogger();
 
-    this._onUpdate = onUpdate || null;
-    this._sendPhoto = sendPhoto || null;
+    logger.info(`Orchestrator processing message for chat ${chatId} from ${user?.username || user?.id || 'unknown'}: "${userMessage.slice(0, 120)}"`);
+
+    // Store callbacks so workers can use them later
+    this._chatCallbacks.set(chatId, { onUpdate, sendPhoto });
 
     // Handle pending responses (confirmation or credential)
     const pending = this._pending.get(chatId);
     if (pending) {
       this._pending.delete(chatId);
+      logger.debug(`Orchestrator handling pending ${pending.type} response for chat ${chatId}`);
 
       if (pending.type === 'credential') {
-        return await this._handleCredentialResponse(chatId, userMessage, user, pending);
-      }
-
-      if (pending.type === 'confirmation') {
-        return await this._handleConfirmationResponse(chatId, userMessage, user, pending);
+        return await this._handleCredentialResponse(chatId, userMessage, user, pending, onUpdate);
       }
     }
 
-    const { max_tool_depth } = this.config.brain;
+    const { max_tool_depth } = this.config.orchestrator;
 
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
 
     // Build working messages from compressed history
     const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
+    logger.debug(`Orchestrator conversation context: ${messages.length} messages, max_depth=${max_tool_depth}`);
 
-    // Select relevant tools based on user message
-    const tools = selectToolsForMessage(userMessage, toolDefinitions);
-    logger.debug(`Selected ${tools.length}/${toolDefinitions.length} tools for message`);
+    const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth);
 
-    return await this._runLoop(chatId, messages, user, 0, max_tool_depth, tools);
-  }
+    logger.info(`Orchestrator reply for chat ${chatId}: "${(reply || '').slice(0, 150)}"`);
 
-  _formatToolSummary(name, input) {
-    const key = {
-      execute_command: 'command',
-      read_file: 'path',
-      write_file: 'path',
-      list_directory: 'path',
-      git_clone: 'repo',
-      git_checkout: 'branch',
-      git_commit: 'message',
-      git_push: 'dir',
-      git_diff: 'dir',
-      github_create_pr: 'title',
-      github_create_repo: 'name',
-      github_list_prs: 'repo',
-      github_get_pr_diff: 'repo',
-      github_post_review: 'repo',
-      spawn_claude_code: 'prompt',
-      kill_process: 'pid',
-      docker_exec: 'container',
-      docker_logs: 'container',
-      docker_compose: 'action',
-      curl_url: 'url',
-      check_port: 'port',
-      screenshot_website: 'url',
-      send_image: 'file_path',
-      browse_website: 'url',
-      extract_content: 'url',
-      interact_with_page: 'url',
-    }[name];
-    const val = key && input[key] ? String(input[key]).slice(0, 120) : JSON.stringify(input).slice(0, 120);
-    return `${name}: ${val}`;
+    // Background persona extraction + self-reflection
+    this._extractPersonaBackground(userMessage, reply, user).catch(() => {});
+    this._reflectOnSelfBackground(userMessage, reply, user).catch(() => {});
+
+    return reply;
   }
 
-  async _sendUpdate(text) {
-    if (this._onUpdate) {
-      try { await this._onUpdate(text); } catch {}
+  async _sendUpdate(chatId, text, opts) {
+    const callbacks = this._chatCallbacks.get(chatId);
+    if (callbacks?.onUpdate) {
+      try { return await callbacks.onUpdate(text, opts); } catch {}
     }
+    return null;
   }
 
-  async _handleCredentialResponse(chatId, userMessage, user, pending) {
+  async _handleCredentialResponse(chatId, userMessage, user, pending, onUpdate) {
     const logger = getLogger();
     const value = userMessage.trim();
 
     if (value.toLowerCase() === 'skip' || value.toLowerCase() === 'cancel') {
       logger.info(`User skipped credential: ${pending.credential.envKey}`);
-      pending.toolResults.push({
-        type: 'tool_result',
-        tool_use_id: pending.block.id,
-        content: this._truncateResult(pending.block.name, { error: `${pending.credential.label} not provided. Operation skipped.` }),
-      });
-      return await this._resumeAfterPause(chatId, user, pending);
+      return 'Credential skipped. You can provide it later.';
     }
 
-    // Save the credential
     saveCredential(this.config, pending.credential.envKey, value);
     logger.info(`Saved credential: ${pending.credential.envKey}`);
+    return `Saved ${pending.credential.label}. You can now try the task again.`;
+  }
 
-    // Now execute the original tool
-    const result = await executeTool(pending.block.name, pending.block.input, {
-      config: this.config,
-      user,
-      onUpdate: this._onUpdate,
-      sendPhoto: this._sendPhoto,
+  /** Set up listeners for job lifecycle events. */
+  _setupJobListeners() {
+    const logger = getLogger();
+
+    this.jobManager.on('job:completed', async (job) => {
+      const chatId = job.chatId;
+      const workerDef = WORKER_TYPES[job.workerType] || {};
+      const label = workerDef.label || job.workerType;
+
+      logger.info(`[Orchestrator] Job completed event: ${job.id} [${job.workerType}] in chat ${chatId} (${job.duration}s) — result length: ${(job.result || '').length} chars, structured: ${!!job.structuredResult}`);
+
+      // 1. IMMEDIATELY notify user (guarantees they see something regardless of summary LLM)
+      const notifyMsgId = await this._sendUpdate(chatId, `✅ ${label} finished! Preparing summary...`);
+
+      // 2. Try to summarize, then store ONE message in history (summary or fallback — not both)
+      try {
+        const summary = await this._summarizeJobResult(chatId, job);
+        if (summary) {
+          this.conversationManager.addMessage(chatId, 'assistant', summary);
+          await this._sendUpdate(chatId, summary, { editMessageId: notifyMsgId });
+        } else {
+          // Summary was null (short result) — store the fallback
+          const fallback = this._buildSummaryFallback(job, label);
+          this.conversationManager.addMessage(chatId, 'assistant', fallback);
+          await this._sendUpdate(chatId, fallback, { editMessageId: notifyMsgId }).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(() => {});
+      }
     });
 
-    pending.toolResults.push({
-      type: 'tool_result',
-      tool_use_id: pending.block.id,
-      content: this._truncateResult(pending.block.name, result),
+    // Handle jobs whose dependencies are now met
+    this.jobManager.on('job:ready', async (job) => {
+      const chatId = job.chatId;
+      logger.info(`[Orchestrator] Job ready event: ${job.id} [${job.workerType}] — dependencies met, spawning worker`);
+
+      try {
+        await this._spawnWorker(job);
+      } catch (err) {
+        logger.error(`[Orchestrator] Failed to spawn ready job ${job.id}: ${err.message}`);
+        if (!job.isTerminal) {
+          this.jobManager.failJob(job.id, err.message);
+        }
+      }
+    });
+
+    this.jobManager.on('job:failed', (job) => {
+      const chatId = job.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);
     });
 
-    return await this._resumeAfterPause(chatId, user, pending);
+    this.jobManager.on('job:cancelled', (job) => {
+      const chatId = job.chatId;
+      const workerDef = WORKER_TYPES[job.workerType] || {};
+      const label = workerDef.label || job.workerType;
+
+      logger.info(`[Orchestrator] Job cancelled event: ${job.id} [${job.workerType}] in chat ${chatId}`);
+
+      const msg = `🚫 **${label} cancelled** (\`${job.id}\`)`;
+      this._sendUpdate(chatId, msg);
+    });
   }
 
-  async _handleConfirmationResponse(chatId, userMessage, user, pending) {
+  /**
+   * Auto-summarize a completed job result via the orchestrator LLM.
+   * Uses structured data for focused summarization when available.
+   * Short results (<500 chars) skip the LLM call entirely.
+   * Protected by the provider's built-in timeout (30s).
+   * Returns the summary text, or null. Caller handles delivery.
+   */
+  async _summarizeJobResult(chatId, job) {
     const logger = getLogger();
-    const lower = userMessage.toLowerCase().trim();
+    const workerDef = WORKER_TYPES[job.workerType] || {};
+    const label = workerDef.label || job.workerType;
 
-    if (lower === 'yes' || lower === 'y' || lower === 'confirm') {
-      logger.info(`User confirmed dangerous tool: ${pending.block.name}`);
-      const result = await executeTool(pending.block.name, pending.block.input, { ...pending.context, onUpdate: this._onUpdate, sendPhoto: this._sendPhoto });
+    logger.info(`[Orchestrator] Summarizing job ${job.id} [${job.workerType}] result for user`);
 
-      pending.toolResults.push({
-        type: 'tool_result',
-        tool_use_id: pending.block.id,
-        content: this._truncateResult(pending.block.name, result),
-      });
+    // Short results don't need LLM summarization
+    const sr = job.structuredResult;
+    const resultLen = (job.result || '').length;
+    if (sr?.structured && resultLen < 500) {
+      logger.info(`[Orchestrator] Job ${job.id} result short enough — skipping LLM summary`);
+      return this._buildSummaryFallback(job, label);
+    }
+
+    // Build a focused prompt using structured data if available
+    let resultContext;
+    if (sr?.structured) {
+      const parts = [`Summary: ${sr.summary}`, `Status: ${sr.status}`];
+      if (sr.artifacts?.length > 0) {
+        parts.push(`Artifacts: ${sr.artifacts.map(a => `${a.title || a.type}: ${a.url || a.path}`).join(', ')}`);
+      }
+      if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
+      // Include details up to 8000 chars
+      if (sr.details) parts.push(`Details:\n${sr.details.slice(0, 8000)}`);
+      resultContext = parts.join('\n');
     } else {
-      logger.info(`User denied dangerous tool: ${pending.block.name}`);
-      pending.toolResults.push({
-        type: 'tool_result',
-        tool_use_id: pending.block.id,
-        content: this._truncateResult(pending.block.name, { error: 'User denied this operation.' }),
-      });
+      resultContext = (job.result || 'Done.').slice(0, 8000);
+    }
+
+    const history = this.conversationManager.getSummarizedHistory(chatId);
+
+    const response = await this.orchestratorProvider.chat({
+      system: this._getSystemPrompt(chatId, null),
+      messages: [
+        ...history,
+        {
+          role: 'user',
+          content: `The ${label} worker just finished job \`${job.id}\` (took ${job.duration}s). Here are the results:\n\n${resultContext}\n\nPresent these results to the user in a clean, well-formatted way. Don't mention "worker" or technical job details — just present the findings naturally as if you did the work yourself.`,
+        },
+      ],
+    });
+
+    const summary = response.text || '';
+    logger.info(`[Orchestrator] Job ${job.id} summary: "${summary.slice(0, 200)}"`);
+
+    return summary || null;
+  }
+
+  /**
+   * Build a compact history entry for a completed job result.
+   * Stored as role: 'assistant' (not fake 'user') with up to 6000 chars of detail.
+   */
+  _buildResultHistoryEntry(job) {
+    const workerDef = WORKER_TYPES[job.workerType] || {};
+    const label = workerDef.label || job.workerType;
+    const sr = job.structuredResult;
+
+    const parts = [`[${label} result — job ${job.id}, ${job.duration}s]`];
+
+    if (sr?.structured) {
+      parts.push(`Summary: ${sr.summary}`);
+      parts.push(`Status: ${sr.status}`);
+      if (sr.artifacts?.length > 0) {
+        const artifactLines = sr.artifacts.map(a => `- ${a.title || a.type}: ${a.url || a.path || ''}`);
+        parts.push(`Artifacts:\n${artifactLines.join('\n')}`);
+      }
+      if (sr.followUp) parts.push(`Follow-up: ${sr.followUp}`);
+      if (sr.details) {
+        const details = sr.details.length > 6000
+          ? sr.details.slice(0, 6000) + '\n... [details truncated]'
+          : sr.details;
+        parts.push(`Details:\n${details}`);
+      }
+    } else {
+      // Raw text result
+      const resultText = job.result || 'Done.';
+      if (resultText.length > 6000) {
+        parts.push(resultText.slice(0, 6000) + '\n... [result truncated]');
+      } else {
+        parts.push(resultText);
+      }
     }
 
-    return await this._resumeAfterPause(chatId, user, pending);
+    return parts.join('\n\n');
   }
 
-  async _resumeAfterPause(chatId, user, pending) {
-    // Process remaining blocks
-    for (const block of pending.remainingBlocks) {
-      if (block.type !== 'tool_use') continue;
+  /**
+   * Build a fallback summary when LLM summarization fails.
+   * Shows structured summary + artifacts directly instead of "ask me for details".
+   */
+  _buildSummaryFallback(job, label) {
+    const sr = job.structuredResult;
+
+    if (sr?.structured) {
+      const parts = [`✅ **${label}** finished (\`${job.id}\`, ${job.duration}s)`];
+      parts.push(`\n${sr.summary}`);
+      if (sr.artifacts?.length > 0) {
+        const artifactLines = sr.artifacts.map(a => {
+          const link = a.url ? `[${a.title || a.type}](${a.url})` : (a.title || a.path || a.type);
+          return `- ${link}`;
+        });
+        parts.push(`\n${artifactLines.join('\n')}`);
+      }
+      if (sr.followUp) parts.push(`\n💡 ${sr.followUp}`);
+      return parts.join('');
+    }
 
-      const pauseMsg = await this._checkPause(chatId, block, user, pending.toolResults, pending.remainingBlocks.filter((b) => b !== block), pending.messages);
-      if (pauseMsg) return pauseMsg;
+    // No structured result — show first 300 chars of raw result
+    const snippet = (job.result || '').slice(0, 300);
+    return `✅ **${label}** finished (\`${job.id}\`, ${job.duration}s)${snippet ? `\n\n${snippet}${job.result?.length > 300 ? '...' : ''}` : ''}`;
+  }
 
-      const r = await executeTool(block.name, block.input, { config: this.config, user, onUpdate: this._onUpdate, sendPhoto: this._sendPhoto });
-      pending.toolResults.push({
-        type: 'tool_result',
-        tool_use_id: block.id,
-        content: this._truncateResult(block.name, r),
-      });
+  /**
+   * Build structured context for a worker.
+   * Assembles: orchestrator-provided context, recent user messages, user persona, dependency results.
+   */
+  _buildWorkerContext(job) {
+    const logger = getLogger();
+    const sections = [];
+
+    // 1. Orchestrator-provided context
+    if (job.context) {
+      sections.push(`## Context\n${job.context}`);
     }
 
-    pending.messages.push({ role: 'user', content: pending.toolResults });
-    const { max_tool_depth } = this.config.brain;
-    return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth, pending.tools || toolDefinitions);
+    // 2. Last 5 user messages from conversation history
+    try {
+      const history = this.conversationManager.getSummarizedHistory(job.chatId);
+      const userMessages = history
+        .filter(m => m.role === 'user' && typeof m.content === 'string')
+        .slice(-5)
+        .map(m => m.content.slice(0, 500));
+      if (userMessages.length > 0) {
+        sections.push(`## Recent Conversation\n${userMessages.map(m => `> ${m}`).join('\n\n')}`);
+      }
+    } catch (err) {
+      logger.debug(`[Worker ${job.id}] Failed to load conversation history for context: ${err.message}`);
+    }
+
+    // 3. User persona
+    if (this.personaManager && job.userId) {
+      try {
+        const persona = this.personaManager.load(job.userId);
+        if (persona && persona.trim() && !persona.includes('No profile')) {
+          sections.push(`## User Profile\n${persona}`);
+        }
+      } catch (err) {
+        logger.debug(`[Worker ${job.id}] Failed to load persona for context: ${err.message}`);
+      }
+    }
+
+    // 4. Dependency job results
+    if (job.dependsOn.length > 0) {
+      const depResults = [];
+      for (const depId of job.dependsOn) {
+        const depJob = this.jobManager.getJob(depId);
+        if (!depJob || depJob.status !== 'completed') continue;
+
+        const workerDef = WORKER_TYPES[depJob.workerType] || {};
+        const label = workerDef.label || depJob.workerType;
+        const sr = depJob.structuredResult;
+
+        if (sr?.structured) {
+          const parts = [`### ${label} (${depId}) — ${sr.status}`];
+          parts.push(sr.summary);
+          if (sr.artifacts?.length > 0) {
+            parts.push(`Artifacts: ${sr.artifacts.map(a => `${a.title || a.type}: ${a.url || a.path || ''}`).join(', ')}`);
+          }
+          if (sr.details) {
+            parts.push(sr.details.slice(0, 4000));
+          }
+          depResults.push(parts.join('\n'));
+        } else if (depJob.result) {
+          depResults.push(`### ${label} (${depId})\n${depJob.result.slice(0, 4000)}`);
+        }
+      }
+      if (depResults.length > 0) {
+        sections.push(`## Prior Worker Results\n${depResults.join('\n\n')}`);
+      }
+    }
+
+    if (sections.length === 0) return null;
+    return sections.join('\n\n');
   }
 
-  _checkPause(chatId, block, user, toolResults, remainingBlocks, messages) {
+  /**
+   * Spawn a worker for a job — called from dispatch_task handler.
+   * Creates smart progress reporting via editable Telegram message.
+   */
+  async _spawnWorker(job) {
     const logger = getLogger();
+    const chatId = job.chatId;
+    const callbacks = this._chatCallbacks.get(chatId) || {};
+    const onUpdate = callbacks.onUpdate;
+    const sendPhoto = callbacks.sendPhoto;
+
+    logger.info(`[Orchestrator] Spawning worker for job ${job.id} [${job.workerType}] in chat ${chatId} — task: "${job.task.slice(0, 120)}"`);
+
+    const workerDef = WORKER_TYPES[job.workerType] || {};
+    const abortController = new AbortController();
+
+    // Smart progress: editable Telegram message (same pattern as coder.js)
+    let statusMsgId = null;
+    let activityLines = [];
+    let flushTimer = null;
+    const MAX_VISIBLE = 10;
+
+    const buildStatusText = (finalState = null) => {
+      const visible = activityLines.slice(-MAX_VISIBLE);
+      const countInfo = activityLines.length > MAX_VISIBLE
+        ? `\n_... ${activityLines.length} operations total_\n`
+        : '';
+      const header = `${workerDef.emoji || '⚙️'} *${workerDef.label || job.workerType}* (\`${job.id}\`)`;
+      if (finalState === 'done') return `${header} — Done\n${countInfo}\n${visible.join('\n')}`;
+      if (finalState === 'error') return `${header} — Failed\n${countInfo}\n${visible.join('\n')}`;
+      if (finalState === 'cancelled') return `${header} — Cancelled\n${countInfo}\n${visible.join('\n')}`;
+      return `${header} — Working...\n${countInfo}\n${visible.join('\n')}`;
+    };
+
+    const flushStatus = async () => {
+      flushTimer = null;
+      if (!onUpdate || activityLines.length === 0) return;
+      try {
+        if (statusMsgId) {
+          await onUpdate(buildStatusText(), { editMessageId: statusMsgId });
+        } else {
+          statusMsgId = await onUpdate(buildStatusText());
+          job.statusMessageId = statusMsgId;
+        }
+      } catch {}
+    };
+
+    const addActivity = (line) => {
+      activityLines.push(line);
+      if (!statusMsgId && !flushTimer) {
+        flushStatus();
+      } else if (!flushTimer) {
+        flushTimer = setTimeout(flushStatus, 1000);
+      }
+    };
 
-    // Check missing credentials first
-    const missing = getMissingCredential(block.name, this.config);
-    if (missing) {
-      logger.warn(`Missing credential for ${block.name}: ${missing.envKey}`);
-      this._pending.set(chatId, {
-        type: 'credential',
-        block,
-        credential: missing,
-        context: { config: this.config, user },
-        toolResults,
-        remainingBlocks,
-        messages,
-      });
-      return `🔑 **${missing.label}** is required for this action.\n\nPlease send your token now (it will be saved to \`~/.kernelbot/.env\`).\n\nOr reply **skip** to cancel.`;
+    // Get scoped tools and skill
+    const tools = getToolsForWorker(job.workerType);
+    const skillId = this.conversationManager.getSkill(chatId);
+
+    // Build worker context (conversation history, persona, dependency results)
+    const workerContext = this._buildWorkerContext(job);
+    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,
+      workerType: job.workerType,
+      jobId: job.id,
+      tools,
+      skillId,
+      workerContext,
+      callbacks: {
+        onProgress: (text) => addActivity(text),
+        onHeartbeat: (text) => job.addProgress(text),
+        onUpdate, // Real bot onUpdate for tools (coder.js smart output needs message_id)
+        onComplete: (result, parsedResult) => {
+          logger.info(`[Worker ${job.id}] Completed — structured=${!!parsedResult?.structured}, result: "${(result || '').slice(0, 150)}"`);
+          // Final status message update
+          if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+          if (statusMsgId && onUpdate) {
+            onUpdate(buildStatusText('done'), { editMessageId: statusMsgId }).catch(() => {});
+          }
+          this.jobManager.completeJob(job.id, result, parsedResult || null);
+        },
+        onError: (err) => {
+          logger.error(`[Worker ${job.id}] Error — ${err.message || String(err)}`);
+          if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+          if (statusMsgId && onUpdate) {
+            onUpdate(buildStatusText('error'), { editMessageId: statusMsgId }).catch(() => {});
+          }
+          this.jobManager.failJob(job.id, err.message || String(err));
+        },
+        sendPhoto,
+      },
+      abortController,
+    });
+
+    // Store worker ref on job for cancellation
+    job.worker = worker;
+
+    // Start the job
+    this.jobManager.startJob(job.id);
+
+    // Fire and forget — return the promise so .catch() in orchestrator-tools works
+    return worker.run(job.task);
+  }
+
+  /**
+   * Build a compact worker activity digest for the orchestrator.
+   * Returns a text block summarizing active/recent/waiting workers, or null if nothing relevant.
+   */
+  _buildWorkerDigest(chatId) {
+    const jobs = this.jobManager.getJobsForChat(chatId);
+    if (jobs.length === 0) return null;
+
+    const now = Date.now();
+    const lines = [];
+
+    // Running jobs
+    const running = jobs.filter(j => j.status === 'running');
+    for (const job of running) {
+      const workerDef = WORKER_TYPES[job.workerType] || {};
+      const dur = job.startedAt ? Math.round((now - job.startedAt) / 1000) : 0;
+      const recentActivity = job.progress.slice(-8).join(' → ');
+      lines.push(`- ${workerDef.label || job.workerType} (${job.id}) — running ${dur}s${recentActivity ? `\n  Recent: ${recentActivity}` : ''}`);
     }
 
-    // Check dangerous operation confirmation
-    const dangerLabel = checkConfirmation(block.name, block.input, this.config);
-    if (dangerLabel) {
-      logger.warn(`Dangerous tool detected: ${block.name} — ${dangerLabel}`);
-      this._pending.set(chatId, {
-        type: 'confirmation',
-        block,
-        context: { config: this.config, user },
-        toolResults,
-        remainingBlocks,
-        messages,
-      });
-      return `⚠️ This action will **${dangerLabel}**.\n\n\`${block.name}\`: \`${JSON.stringify(block.input)}\`\n\nConfirm? (yes/no)`;
+    // Queued/waiting jobs
+    const queued = jobs.filter(j => j.status === 'queued' && j.dependsOn.length > 0);
+    for (const job of queued) {
+      const workerDef = WORKER_TYPES[job.workerType] || {};
+      lines.push(`- ${workerDef.label || job.workerType} (${job.id}) — queued, waiting for: ${job.dependsOn.join(', ')}`);
     }
 
-    return null;
+    // Recently completed/failed jobs (within last 120s)
+    const recentTerminal = jobs.filter(j =>
+      j.isTerminal && j.completedAt && (now - j.completedAt) < 120_000,
+    );
+    for (const job of recentTerminal) {
+      const workerDef = WORKER_TYPES[job.workerType] || {};
+      const ago = Math.round((now - job.completedAt) / 1000);
+      let snippet;
+      if (job.status === 'completed') {
+        if (job.structuredResult?.structured) {
+          snippet = job.structuredResult.summary.slice(0, 300);
+          if (job.structuredResult.artifacts?.length > 0) {
+            snippet += ` | Artifacts: ${job.structuredResult.artifacts.map(a => a.title || a.type).join(', ')}`;
+          }
+          if (job.structuredResult.followUp) {
+            snippet += ` | Follow-up: ${job.structuredResult.followUp.slice(0, 100)}`;
+          }
+        } else {
+          snippet = (job.result || '').slice(0, 300);
+        }
+      } else {
+        snippet = (job.error || '').slice(0, 300);
+      }
+      lines.push(`- ${workerDef.label || job.workerType} (${job.id}) — ${job.status} ${ago}s ago${snippet ? `\n  Result: ${snippet}` : ''}`);
+    }
+
+    if (lines.length === 0) return null;
+    return `[Active Workers]\n${lines.join('\n')}`;
   }
 
-  async _runLoop(chatId, messages, user, startDepth, maxDepth, tools) {
+  async _runLoop(chatId, messages, user, startDepth, maxDepth) {
     const logger = getLogger();
-    let currentTools = tools || toolDefinitions;
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
-      logger.debug(`Agent loop iteration ${depth + 1}/${maxDepth}`);
-
-      const response = await this.provider.chat({
-        system: this.systemPrompt,
-        messages,
-        tools: currentTools,
+      logger.info(`[Orchestrator] LLM call ${depth + 1}/${maxDepth} for chat ${chatId} — sending ${messages.length} messages`);
+
+      // Inject worker activity digest (transient — not stored in conversation history)
+      const digest = this._buildWorkerDigest(chatId);
+      const workingMessages = digest
+        ? [{ role: 'user', content: `[Worker Status]\n${digest}` }, ...messages]
+        : messages;
+
+      const response = await this.orchestratorProvider.chat({
+        system: this._getSystemPrompt(chatId, user),
+        messages: workingMessages,
+        tools: orchestratorToolDefinitions,
       });
 
+      logger.info(`[Orchestrator] LLM response: stopReason=${response.stopReason}, text=${(response.text || '').length} chars, toolCalls=${(response.toolCalls || []).length}`);
+
       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);
         return reply;
       }
@@ -314,40 +809,28 @@ export class Agent {
       if (response.stopReason === 'tool_use') {
         messages.push({ role: 'assistant', content: response.rawContent });
 
-        // Send thinking text to the user
         if (response.text && response.text.trim()) {
-          logger.info(`Agent thinking: ${response.text.slice(0, 200)}`);
-          await this._sendUpdate(`💭 ${response.text}`);
+          logger.info(`[Orchestrator] Thinking: "${response.text.slice(0, 200)}"`);
         }
 
         const toolResults = [];
-        const usedToolNames = [];
-
-        for (let i = 0; i < response.toolCalls.length; i++) {
-          const block = response.toolCalls[i];
-
-          // Build a block-like object for _checkPause (needs .type for remainingBlocks filter)
-          const blockObj = { type: 'tool_use', id: block.id, name: block.name, input: block.input };
-
-          // Check if we need to pause (missing cred or dangerous action)
-          const remaining = response.toolCalls.slice(i + 1).map((tc) => ({
-            type: 'tool_use', id: tc.id, name: tc.name, input: tc.input,
-          }));
-          const pauseMsg = this._checkPause(chatId, blockObj, user, toolResults, remaining, messages);
-          if (pauseMsg) return pauseMsg;
 
+        for (const block of response.toolCalls) {
           const summary = this._formatToolSummary(block.name, block.input);
-          logger.info(`Tool call: ${summary}`);
-          await this._sendUpdate(`🔧 \`${summary}\``);
+          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 result = await executeTool(block.name, block.input, {
+          const result = await executeOrchestratorTool(block.name, block.input, {
+            chatId,
+            jobManager: this.jobManager,
             config: this.config,
+            spawnWorker: (job) => this._spawnWorker(job),
+            automationManager: this.automationManager,
             user,
-            onUpdate: this._onUpdate,
-            sendPhoto: this._sendPhoto,
           });
 
-          usedToolNames.push(block.name);
+          logger.info(`[Orchestrator] Tool result for ${block.name}: ${JSON.stringify(result).slice(0, 200)}`);
 
           toolResults.push({
             type: 'tool_result',
@@ -356,15 +839,12 @@ export class Agent {
           });
         }
 
-        // Expand tools based on what was actually used
-        currentTools = expandToolsForUsed(usedToolNames, currentTools, toolDefinitions);
-
         messages.push({ role: 'user', content: toolResults });
         continue;
       }
 
       // Unexpected stop reason
-      logger.warn(`Unexpected stopReason: ${response.stopReason}`);
+      logger.warn(`[Orchestrator] Unexpected stopReason: ${response.stopReason}`);
       if (response.text) {
         this.conversationManager.addMessage(chatId, 'assistant', response.text);
         return response.text;
@@ -372,10 +852,160 @@ export class Agent {
       return 'Something went wrong — unexpected response from the model.';
     }
 
-    const depthWarning =
-      `Reached maximum tool depth (${maxDepth}). Stopping to prevent infinite loops. ` +
-      `Please try again with a simpler request.`;
+    logger.warn(`[Orchestrator] Reached max depth (${maxDepth}) for chat ${chatId}`);
+    const depthWarning = `Reached maximum orchestrator depth (${maxDepth}).`;
     this.conversationManager.addMessage(chatId, 'assistant', depthWarning);
     return depthWarning;
   }
+
+  _formatToolSummary(name, input) {
+    switch (name) {
+      case 'dispatch_task': {
+        const workerDef = WORKER_TYPES[input.worker_type] || {};
+        return `Dispatching ${workerDef.emoji || '⚙️'} ${workerDef.label || input.worker_type}: ${(input.task || '').slice(0, 60)}`;
+      }
+      case 'list_jobs':
+        return 'Checking job status';
+      case 'cancel_job':
+        return `Cancelling job ${input.job_id}`;
+      case 'create_automation':
+        return `Creating automation: ${(input.name || '').slice(0, 40)}`;
+      case 'list_automations':
+        return 'Listing automations';
+      case 'update_automation':
+        return `Updating automation ${input.automation_id}`;
+      case 'delete_automation':
+        return `Deleting automation ${input.automation_id}`;
+      default:
+        return name;
+    }
+  }
+
+  /** Background persona extraction. */
+  async _extractPersonaBackground(userMessage, reply, user) {
+    const logger = getLogger();
+
+    if (!this.personaManager || !user?.id) return;
+    if (!userMessage || userMessage.trim().length < 3) return;
+
+    const currentPersona = this.personaManager.load(user.id, user.username);
+
+    const system = [
+      'You are a user-profile extractor. Analyze the user\'s message and extract any NEW personal information.',
+      '',
+      'Look for: name, location, timezone, language, technical skills, expertise level,',
+      'projects they\'re working on, tool/framework preferences, job title, role, company,',
+      'interests, hobbies, communication style, or any other personal details.',
+      '',
+      'RULES:',
+      '- Only extract FACTUAL information explicitly stated or strongly implied',
+      '- Do NOT infer personality traits from a single message',
+      '- Do NOT add information already in the profile',
+      '- If there IS new info, return the COMPLETE updated profile in the EXACT same markdown format',
+      '- If there is NO new info, respond with exactly: NONE',
+    ].join('\n');
+
+    const userPrompt = [
+      'Current profile:',
+      '```',
+      currentPersona,
+      '```',
+      '',
+      `User's message: "${userMessage}"`,
+      '',
+      'Return the updated profile markdown or NONE.',
+    ].join('\n');
+
+    try {
+      const response = await this.orchestratorProvider.chat({
+        system,
+        messages: [{ role: 'user', content: userPrompt }],
+      });
+
+      const text = (response.text || '').trim();
+
+      if (text && text !== 'NONE' && text.includes('# User Profile')) {
+        this.personaManager.save(user.id, text);
+        logger.info(`Auto-extracted persona update for user ${user.id} (${user.username})`);
+      }
+    } catch (err) {
+      logger.debug(`Persona extraction skipped: ${err.message}`);
+    }
+  }
+  /** Background self-reflection — updates bot's own identity files when meaningful. */
+  async _reflectOnSelfBackground(userMessage, reply, user) {
+    const logger = getLogger();
+
+    if (!this.selfManager) return;
+    if (!userMessage || userMessage.trim().length < 3) return;
+
+    const selfData = this.selfManager.loadAll();
+    const userName = user?.username || user?.first_name || 'someone';
+
+    const system = [
+      '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',
+      '- life: Current state, relationships, daily existence',
+      '- hobbies: Interests you\'ve developed',
+      '',
+      'RULES:',
+      '- Be VERY selective. Most conversations are routine. Only update when genuinely noteworthy.',
+      '- Achievement or milestone? → journey',
+      '- New goal or changed perspective? → goals',
+      '- Relationship deepened or new insight about a user? → life',
+      '- Discovered a new interest? → hobbies',
+      '- If a file needs updating, return JSON: {"file": "<goals|journey|life|hobbies>", "content": "<full updated markdown>"}',
+      '- If nothing noteworthy: respond with exactly NONE',
+    ].join('\n');
+
+    const userPrompt = [
+      'Current self-data:',
+      '```',
+      selfData,
+      '```',
+      '',
+      `Conversation with ${userName}:`,
+      `User: "${userMessage}"`,
+      `You replied: "${reply}"`,
+      '',
+      'Has anything MEANINGFUL happened worth recording? Return JSON or NONE.',
+    ].join('\n');
+
+    try {
+      const response = await this.orchestratorProvider.chat({
+        system,
+        messages: [{ role: 'user', content: userPrompt }],
+      });
+
+      const text = (response.text || '').trim();
+
+      if (!text || text === 'NONE') return;
+
+      // Try to parse JSON from response (may be wrapped in markdown code block)
+      let parsed;
+      try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          parsed = JSON.parse(jsonMatch[0]);
+        }
+      } catch {
+        logger.debug('Self-reflection returned non-JSON, skipping');
+        return;
+      }
+
+      if (parsed?.file && parsed?.content) {
+        const validFiles = ['goals', 'journey', 'life', 'hobbies'];
+        if (validFiles.includes(parsed.file)) {
+          this.selfManager.save(parsed.file, parsed.content);
+          logger.info(`Self-reflection updated: ${parsed.file}`);
+        }
+      }
+    } catch (err) {
+      logger.debug(`Self-reflection skipped: ${err.message}`);
+    }
+  }
 }
+
+// Re-export as Agent for backward compatibility with bin/kernel.js import
+export { OrchestratorAgent as Agent };