neoagent 1.4.1 → 1.4.4

package/server/services/ai/toolResult.js

@@ -0,0 +1,151 @@
+function clampText(text, maxChars) {
+  const str = String(text || '');
+  if (str.length <= maxChars) return str;
+  return `${str.slice(0, maxChars)}\n...[truncated, ${str.length} chars total]`;
+}
+
+function lineExcerpt(text, maxLines = 12, maxChars = 700) {
+  const str = String(text || '').trim();
+  if (!str) return '';
+  return clampText(str.split('\n').slice(0, maxLines).join('\n'), maxChars);
+}
+
+function toJsonText(value, maxChars) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+  return clampText(raw, maxChars);
+}
+
+function trimObject(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined && value !== null && value !== ''));
+}
+
+function clampEnvelope(envelope, hardLimit) {
+  const raw = JSON.stringify(envelope);
+  if (raw.length <= hardLimit) return raw;
+
+  const trimmed = { ...envelope };
+  if (trimmed.summary) trimmed.summary = clampText(trimmed.summary, Math.max(200, hardLimit - 300));
+  if (trimmed.stdout) trimmed.stdout = clampText(trimmed.stdout, Math.max(160, hardLimit - 400));
+  if (trimmed.stderr) trimmed.stderr = clampText(trimmed.stderr, Math.max(120, hardLimit - 400));
+  if (trimmed.content) trimmed.content = clampText(trimmed.content, Math.max(160, hardLimit - 400));
+  if (trimmed.excerpt) trimmed.excerpt = clampText(trimmed.excerpt, Math.max(160, hardLimit - 400));
+  if (trimmed.result) trimmed.result = clampText(trimmed.result, Math.max(160, hardLimit - 400));
+
+  const fallback = JSON.stringify(trimmed);
+  if (fallback.length <= hardLimit) return fallback;
+  return clampText(fallback, hardLimit);
+}
+
+function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
+  const softLimit = Math.max(400, Math.min(Number(options.softLimit) || 1200, 2000));
+  const hardLimit = Math.max(softLimit, Math.min(Number(options.hardLimit) || 2000, 3000));
+
+  let envelope;
+
+  switch (toolName) {
+    case 'execute_command':
+      envelope = trimObject({
+        tool: toolName,
+        exitCode: toolResult?.exitCode,
+        cwd: toolResult?.cwd || toolArgs.cwd,
+        killed: toolResult?.killed || false,
+        stdout: lineExcerpt(toolResult?.stdout, 12, Math.floor(softLimit * 0.45)),
+        stderr: lineExcerpt(toolResult?.stderr, 8, Math.floor(softLimit * 0.25))
+      });
+      break;
+
+    case 'read_file':
+      envelope = trimObject({
+        tool: toolName,
+        path: toolArgs.path,
+        startLine: toolArgs.start_line,
+        endLine: toolArgs.end_line,
+        content: lineExcerpt(toolResult?.content || toolResult, 20, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'search_files':
+      envelope = trimObject({
+        tool: toolName,
+        count: toolResult?.count || toolResult?.matches?.length || 0,
+        matches: (toolResult?.matches || []).slice(0, 6).map((match) => trimObject({
+          file: match.file,
+          line: match.line,
+          content: clampText(match.content, 160)
+        }))
+      });
+      break;
+
+    case 'browser_extract':
+      envelope = trimObject({
+        tool: toolName,
+        selector: toolArgs.selector || 'body',
+        attribute: toolArgs.attribute || 'innerText',
+        excerpt: lineExcerpt(toolResult?.result || toolResult?.content || toolResult, 18, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'http_request':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.status,
+        headers: trimObject({
+          contentType: toolResult?.headers?.['content-type'] || toolResult?.headers?.['Content-Type'],
+          contentLength: toolResult?.headers?.['content-length'] || toolResult?.headers?.['Content-Length']
+        }),
+        excerpt: lineExcerpt(toolResult?.body || toolResult, 18, Math.floor(softLimit * 0.65))
+      });
+      break;
+
+    case 'send_message':
+    case 'make_call':
+    case 'memory_save':
+    case 'memory_recall':
+    case 'memory_update_core':
+    case 'memory_read':
+    case 'memory_write':
+    case 'create_scheduled_task':
+    case 'schedule_run':
+    case 'list_scheduled_tasks':
+    case 'delete_scheduled_task':
+    case 'update_scheduled_task':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        message: clampText(toolResult?.message || toolResult?.error || '', Math.floor(softLimit * 0.45)),
+        result: clampText(JSON.stringify(trimObject({
+          id: toolResult?.id,
+          key: toolResult?.key,
+          deleted: toolResult?.deleted,
+          sent: toolResult?.sent,
+          count: Array.isArray(toolResult?.results) ? toolResult.results.length : undefined
+        })), Math.floor(softLimit * 0.35))
+      });
+      break;
+
+    case 'spawn_subagent':
+      envelope = trimObject({
+        tool: toolName,
+        iterations: toolResult?.iterations,
+        tokens: toolResult?.tokens,
+        runId: toolResult?.runId,
+        summary: clampText(toolResult?.subagent_result || toolResult?.error || '', Math.floor(softLimit * 0.55))
+      });
+      break;
+
+    default:
+      envelope = trimObject({
+        tool: toolName,
+        summary: toJsonText(toolResult, Math.floor(softLimit * 0.75))
+      });
+      break;
+  }
+
+  return clampEnvelope(envelope, hardLimit);
+}
+
+module.exports = {
+  compactToolResult,
+  clampText,
+  lineExcerpt
+};

package/server/services/ai/toolRunner.js

@@ -87,7 +87,7 @@ class SkillRunner {
   }
 
   getSkillsForPrompt() {
-    const skills = Array.from(this.skills.values());
+    const skills = Array.from(this.skills.values()).filter((skill) => skill.metadata.enabled !== false);
     if (skills.length === 0) return '';
 
     let prompt = '\n## Available Skills\n';
@@ -103,7 +103,7 @@ class SkillRunner {
   getToolDefinitions() {
     const tools = [];
     for (const skill of this.skills.values()) {
-      if (skill.metadata.tool) {
+      if (skill.metadata.enabled !== false && skill.metadata.tool) {
         tools.push({
           name: skill.name,
           description: skill.description,
@@ -117,6 +117,9 @@ class SkillRunner {
   async executeTool(toolName, args) {
     const skill = this.skills.get(toolName);
     if (!skill) return null;
+    if (skill.metadata.enabled === false) {
+      return { error: `Skill '${toolName}' is disabled` };
+    }
 
     if (skill.metadata.command) {
       const { CLIExecutor } = require('../cli/executor');
@@ -140,8 +143,10 @@ class SkillRunner {
     const filePath = path.join(skillDir, 'SKILL.md');
     fs.writeFileSync(filePath, frontmatter + `\n\n${instructions}`);
 
-    db.prepare('INSERT OR REPLACE INTO skills (name, description, file_path, metadata, auto_created, updated_at) VALUES (?, ?, ?, ?, 1, datetime(\'now\'))')
-      .run(safeName, description, filePath, JSON.stringify(metadata));
+    db.prepare(`
+      INSERT OR REPLACE INTO skills (name, description, file_path, metadata, enabled, auto_created, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, datetime('now'))
+    `).run(safeName, description, filePath, JSON.stringify(metadata), metadata.enabled === false ? 0 : 1);
 
     this.loadSkillFile(filePath);
 
@@ -167,12 +172,24 @@ class SkillRunner {
 
     const frontmatter = this._buildFrontmatter(name, newDesc, metaToWrite);
     fs.writeFileSync(skill.filePath, frontmatter + `\n\n${newInstructions}`);
-    db.prepare('UPDATE skills SET description = ?, updated_at = datetime(\'now\') WHERE name = ?').run(newDesc, name);
+    db.prepare('UPDATE skills SET description = ?, metadata = ?, enabled = ?, updated_at = datetime(\'now\') WHERE name = ?')
+      .run(newDesc, JSON.stringify(metaToWrite || {}), metaToWrite?.enabled === false ? 0 : 1, name);
     this.loadSkillFile(skill.filePath);
 
     return { success: true, name, path: skill.filePath };
   }
 
+  getSkill(name) {
+    return this.skills.get(name) || null;
+  }
+
+  setSkillEnabled(name, enabled) {
+    const skill = this.skills.get(name);
+    if (!skill) return { error: `Skill '${name}' not found` };
+    const metadata = { ...skill.metadata, enabled: !!enabled };
+    return this.updateSkill(name, { metadata });
+  }
+
   deleteSkill(name) {
     const skill = this.skills.get(name);
     if (!skill) return { error: `Skill '${name}' not found` };
@@ -211,7 +228,8 @@ class SkillRunner {
       name: s.name,
       description: s.description,
       metadata: s.metadata,
-      filePath: s.filePath
+      filePath: s.filePath,
+      enabled: s.metadata.enabled !== false
     }));
   }
 }

package/server/services/ai/toolSelector.js

@@ -0,0 +1,140 @@
+const ALWAYS_ON_TOOLS = ['notify_user'];
+
+const PACKS = {
+  code: ['execute_command', 'read_file', 'list_directory', 'search_files'],
+  web: ['web_search', 'http_request', 'browser_navigate', 'browser_extract', 'browser_click', 'browser_type', 'browser_screenshot'],
+  messaging: ['send_message', 'make_call'],
+  memory: ['memory_recall', 'session_search', 'memory_save', 'memory_update_core', 'memory_read', 'memory_write'],
+  scheduling: ['create_scheduled_task', 'schedule_run', 'list_scheduled_tasks', 'update_scheduled_task', 'delete_scheduled_task'],
+  protocols: ['manage_protocols'],
+  skills: ['create_skill', 'list_skills', 'update_skill', 'delete_skill'],
+  images: ['generate_image', 'analyze_image'],
+  tables: ['generate_table', 'generate_graph'],
+  subagents: ['spawn_subagent'],
+  mcpAdmin: ['mcp_add_server', 'mcp_list_servers', 'mcp_remove_server']
+};
+
+function containsAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function detectRequestedPacks(task = '', options = {}) {
+  const text = String(task || '').toLowerCase();
+  const packs = new Set();
+
+  if (containsAny(text, [
+    /\b(run|execute|command|shell|terminal|bash|zsh|npm|node|python|script|repo|code|bug|fix|patch|test|build|file|folder|directory|grep|search files?)\b/,
+    /\b(read|open|inspect)\s+(the\s+)?(file|repo|code)\b/
+  ])) {
+    packs.add('code');
+  }
+
+  if (containsAny(text, [
+    /\b(web|website|url|page|browser|click|navigate|scrape|search|google|lookup|http|fetch|api request|screenshot)\b/,
+    /\bopen\b.*\bsite\b/
+  ])) {
+    packs.add('web');
+  }
+
+  if (containsAny(text, [
+    /\b(message|reply|respond|text|whatsapp|telegram|discord|dm|email|call|phone|notify|send to)\b/,
+    /\[no response\]/,
+    /\bsend_message\b/,
+    /\bmake_call\b/
+  ])) {
+    packs.add('messaging');
+  }
+
+  if (containsAny(text, [
+    /\bmemory\b/,
+    /\bremember\b/,
+    /\brecall\b/,
+    /\bprevious chat\b/,
+    /\blast time\b/,
+    /\bpast conversation\b/,
+    /\bpreference\b/,
+    /\bprofile\b/,
+    /\bsoul\b/
+  ])) {
+    packs.add('memory');
+  }
+
+  if (containsAny(text, [
+    /\bschedule\b/,
+    /\bcron\b/,
+    /\bremind\b/,
+    /\brecurring\b/,
+    /\bweekly\b/,
+    /\bdaily\b/,
+    /\bone-time\b/,
+    /\btask\b.*\blater\b/
+  ])) {
+    packs.add('scheduling');
+  }
+
+  if (containsAny(text, [/\bprotocol\b/, /\bplaybook\b/])) {
+    packs.add('protocols');
+  }
+
+  if (containsAny(text, [/\bskill\b/, /\binstall skill\b/, /\bcreate skill\b/])) {
+    packs.add('skills');
+  }
+
+  if (containsAny(text, [/\bimage\b/, /\bpicture\b/, /\bphoto\b/, /\bgraph\b/, /\bchart\b/, /\btable\b/, /\bqr\b/, /\bocr\b/])) {
+    packs.add('images');
+  }
+
+  if (containsAny(text, [/\btable\b/, /\bspreadsheet\b/, /\bgraph\b/, /\bchart\b/])) {
+    packs.add('tables');
+  }
+
+  if (containsAny(text, [/\bsub-?agent\b/, /\bdelegate\b/, /\bparallel\b/, /\bbackground worker\b/])) {
+    packs.add('subagents');
+  }
+
+  if (containsAny(text, [/\bmcp\b/, /\bmodel context protocol\b/, /\bserver tool\b/])) {
+    packs.add('mcpAdmin');
+  }
+
+  if (options.mediaAttachments?.length) {
+    packs.add('images');
+  }
+
+  return packs;
+}
+
+function maybeSelectMcpTools(text, mcpTools = []) {
+  const normalized = String(text || '').toLowerCase();
+  if (!normalized || !mcpTools.length) return [];
+
+  const explicitMcp = /\bmcp\b|\bmodel context protocol\b/.test(normalized);
+  return mcpTools.filter((tool) => {
+    const name = String(tool.name || '').toLowerCase();
+    const original = String(tool.originalName || '').toLowerCase();
+    const server = String(tool.serverId || '').toLowerCase();
+    return explicitMcp || normalized.includes(name) || normalized.includes(original) || (server && normalized.includes(server));
+  });
+}
+
+function selectToolsForTask(task, builtInTools = [], mcpTools = [], options = {}) {
+  const packs = detectRequestedPacks(task, options);
+  const allowNames = new Set(ALWAYS_ON_TOOLS);
+
+  for (const pack of packs) {
+    for (const toolName of PACKS[pack] || []) {
+      allowNames.add(toolName);
+    }
+  }
+
+  const selectedBuiltIns = builtInTools.filter((tool) => allowNames.has(tool.name));
+  const selectedMcp = maybeSelectMcpTools(task, mcpTools);
+
+  return [...selectedBuiltIns, ...selectedMcp];
+}
+
+module.exports = {
+  ALWAYS_ON_TOOLS,
+  PACKS,
+  detectRequestedPacks,
+  selectToolsForTask
+};

package/server/services/ai/tools.js

@@ -3,12 +3,54 @@ const path = require('path');
 const db = require('../../db/database');
 const { DATA_DIR } = require('../../../runtime/paths');
 
+function compactText(text, maxChars = 120) {
+  const str = String(text || '').replace(/\s+/g, ' ').trim();
+  if (str.length <= maxChars) return str;
+  const trimmed = str.slice(0, maxChars);
+  const sentenceBreak = Math.max(trimmed.lastIndexOf('. '), trimmed.lastIndexOf('; '), trimmed.lastIndexOf(', '));
+  if (sentenceBreak > 40) return trimmed.slice(0, sentenceBreak + 1).trim();
+  return `${trimmed.trim()}...`;
+}
+
+function compactToolDefinition(tool, options = {}) {
+  const compact = {
+    name: tool.name,
+    parameters: {
+      ...(tool.parameters || { type: 'object', properties: {} }),
+      properties: {}
+    }
+  };
+
+  if (options.includeDescriptions) {
+    compact.description = compactText(tool.description, 120);
+  }
+
+  if (tool.parameters?.properties) {
+    const properties = {};
+    for (const [key, value] of Object.entries(tool.parameters.properties)) {
+      properties[key] = { ...value };
+      if (options.includeDescriptions && value.description) {
+        properties[key].description = compactText(value.description, 70);
+      } else {
+        delete properties[key].description;
+      }
+    }
+    compact.parameters = {
+      ...compact.parameters,
+      properties
+    };
+  }
+
+  return compact;
+}
+
 /**
  * Returns the list of available tools for the agent.
  * @param {object} app - Express app instance.
+ * @param {object} options - Tool filtering options.
  * @returns {Array} List of tool definitions.
  */
-function getAvailableTools(app) {
+function getAvailableTools(app, options = {}) {
     const tools = [
         {
             name: 'execute_command',
@@ -154,6 +196,18 @@ function getAvailableTools(app) {
                 required: ['query']
             }
         },
+        {
+            name: 'session_search',
+            description: 'Search past runs and message threads for commands, decisions, file paths, or context from earlier conversations.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'What to search for in prior sessions.' },
+                    limit: { type: 'number', description: 'How many matching sessions to return (default 6).' }
+                },
+                required: ['query']
+            }
+        },
         {
             name: 'memory_update_core',
             description: 'Update core memory — always-injected facts that appear in every prompt. Use for critical always-relevant info: user\'s name, their main job, key standing preferences, how they want you to behave. Keep each entry concise.',
@@ -530,7 +584,12 @@ function getAvailableTools(app) {
         }
     ];
 
-    return tools;
+    const compacted = tools.map((tool) => compactToolDefinition(tool, options));
+    if (options.names && Array.isArray(options.names)) {
+        const allow = new Set(options.names);
+        return compacted.filter((tool) => allow.has(tool.name));
+    }
+    return compacted;
 }
 
 /**
@@ -725,6 +784,16 @@ async function executeTool(toolName, args, context, engine) {
             return { results };
         }
 
+        case 'session_search': {
+            const { MemoryManager } = require('../memory/manager');
+            const mm = new MemoryManager();
+            const results = mm.searchConversations(userId, args.query, {
+                sessions: args.limit || 6
+            });
+            if (!results.length) return { results: [], message: 'No matching sessions found' };
+            return { results };
+        }
+
         case 'memory_update_core': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();

package/server/services/health/ingestion.js

@@ -0,0 +1,175 @@
+const crypto = require('crypto');
+const db = require('../../db/database');
+const { v4: uuidv4 } = require('uuid');
+
+function parseIsoOrNull(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function asJson(value) {
+  return JSON.stringify(value == null ? null : value);
+}
+
+function asText(value) {
+  if (value == null) return null;
+  const text = String(value).trim();
+  return text.length ? text : null;
+}
+
+function buildFallbackRecordId(metricType, record) {
+  const hash = crypto.createHash('sha1');
+  hash.update(metricType || '');
+  hash.update('\n');
+  hash.update(asJson(record));
+  return hash.digest('hex');
+}
+
+function normalizeRecord(record = {}) {
+  const metricType = asText(record.metricType || record.type);
+  if (!metricType) return null;
+
+  const payload = record.payload && typeof record.payload === 'object'
+    ? record.payload
+    : {};
+
+  return {
+    metricType,
+    recordId: asText(record.recordId || payload.recordId) || buildFallbackRecordId(metricType, record),
+    startTime: parseIsoOrNull(record.startTime || payload.startTime),
+    endTime: parseIsoOrNull(record.endTime || payload.endTime),
+    recordedAt: parseIsoOrNull(record.recordedAt || payload.recordedAt || record.endTime || record.startTime),
+    numericValue: Number.isFinite(Number(record.numericValue)) ? Number(record.numericValue) : null,
+    textValue: asText(record.textValue),
+    unit: asText(record.unit),
+    sourceAppId: asText(record.sourceAppId || payload.sourceAppId),
+    sourceDevice: asText(record.sourceDevice || payload.sourceDevice),
+    lastModifiedTime: parseIsoOrNull(record.lastModifiedTime || payload.lastModifiedTime),
+    payloadJson: asJson(payload),
+  };
+}
+
+const insertRun = db.prepare(`
+  INSERT INTO health_sync_runs (
+    id, user_id, source, provider, sync_window_start, sync_window_end,
+    record_count, summary_json, payload_json
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+
+const upsertSample = db.prepare(`
+  INSERT INTO health_metric_samples (
+    user_id, sync_run_id, metric_type, record_id, start_time, end_time, recorded_at,
+    numeric_value, text_value, unit, source_app_id, source_device, last_modified_time, payload_json
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(user_id, metric_type, record_id) DO UPDATE SET
+    sync_run_id = excluded.sync_run_id,
+    start_time = excluded.start_time,
+    end_time = excluded.end_time,
+    recorded_at = excluded.recorded_at,
+    numeric_value = excluded.numeric_value,
+    text_value = excluded.text_value,
+    unit = excluded.unit,
+    source_app_id = excluded.source_app_id,
+    source_device = excluded.source_device,
+    last_modified_time = excluded.last_modified_time,
+    payload_json = excluded.payload_json,
+    updated_at = datetime('now')
+`);
+
+const ingestHealthSyncTx = db.transaction((userId, body) => {
+  const runId = uuidv4();
+  const source = asText(body.source) || 'android-health-connect';
+  const provider = asText(body.provider);
+  const windowStart = parseIsoOrNull(body.windowStart);
+  const windowEnd = parseIsoOrNull(body.windowEnd);
+  const records = Array.isArray(body.records)
+    ? body.records.map(normalizeRecord).filter(Boolean)
+    : [];
+
+  insertRun.run(
+    runId,
+    userId,
+    source,
+    provider,
+    windowStart,
+    windowEnd,
+    records.length,
+    asJson(body.summary || {}),
+    asJson(body),
+  );
+
+  for (const record of records) {
+    upsertSample.run(
+      userId,
+      runId,
+      record.metricType,
+      record.recordId,
+      record.startTime,
+      record.endTime,
+      record.recordedAt,
+      record.numericValue,
+      record.textValue,
+      record.unit,
+      record.sourceAppId,
+      record.sourceDevice,
+      record.lastModifiedTime,
+      record.payloadJson,
+    );
+  }
+
+  return {
+    runId,
+    source,
+    provider,
+    windowStart,
+    windowEnd,
+    recordCount: records.length,
+    acceptedMetrics: [...new Set(records.map((record) => record.metricType))],
+  };
+});
+
+function ingestHealthSync(userId, body = {}) {
+  if (!userId) throw new Error('Missing user');
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new Error('Health sync payload must be a JSON object');
+  }
+  return ingestHealthSyncTx(userId, body);
+}
+
+function getHealthSyncStatus(userId) {
+  const lastRun = db.prepare(`
+    SELECT id, source, provider, sync_window_start, sync_window_end, record_count, summary_json, created_at
+    FROM health_sync_runs
+    WHERE user_id = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(userId);
+
+  const metrics = db.prepare(`
+    SELECT metric_type, COUNT(*) AS sample_count, MAX(COALESCE(end_time, recorded_at, start_time)) AS last_seen_at
+    FROM health_metric_samples
+    WHERE user_id = ?
+    GROUP BY metric_type
+    ORDER BY metric_type ASC
+  `).all(userId);
+
+  return {
+    lastRun: lastRun ? {
+      ...lastRun,
+      summary: (() => {
+        try { return JSON.parse(lastRun.summary_json || '{}'); } catch { return {}; }
+      })(),
+    } : null,
+    metrics: metrics.map((metric) => ({
+      metricType: metric.metric_type,
+      sampleCount: Number(metric.sample_count || 0),
+      lastSeenAt: metric.last_seen_at || null,
+    })),
+  };
+}
+
+module.exports = {
+  getHealthSyncStatus,
+  ingestHealthSync,
+};

package/server/services/manager.js

@@ -5,7 +5,9 @@ const { MemoryManager } = require('./memory/manager');
 const { MCPClient } = require('./mcp/client');
 const { BrowserController } = require('./browser/controller');
 const { AgentEngine } = require('./ai/engine');
+const { LearningManager } = require('./ai/learning');
 const { MultiStepOrchestrator } = require('./ai/multiStep');
+const { SkillRunner } = require('./ai/toolRunner');
 const { MessagingManager } = require('./messaging/manager');
 const { Scheduler } = require('./scheduler/cron');
 const { setupWebSocket } = require('./websocket');
@@ -29,7 +31,21 @@ async function startServices(app, io) {
         }
         app.locals.browserController = browserController;
 
-        const agentEngine = new AgentEngine(io, { memoryManager, mcpClient, browserController, messagingManager: null });
+        const skillRunner = new SkillRunner();
+        await skillRunner.loadSkills();
+        app.locals.skillRunner = skillRunner;
+
+        const learningManager = new LearningManager(skillRunner, io);
+        app.locals.learningManager = learningManager;
+
+        const agentEngine = new AgentEngine(io, {
+            memoryManager,
+            mcpClient,
+            browserController,
+            messagingManager: null,
+            skillRunner,
+            learningManager
+        });
         app.locals.agentEngine = agentEngine;
 
         const multiStep = new MultiStepOrchestrator(agentEngine, io);
@@ -167,7 +183,14 @@ async function startServices(app, io) {
         agentEngine.scheduler = scheduler;
         scheduler.start();
 
-        setupWebSocket(io, { agentEngine, messagingManager, mcpClient, scheduler, memoryManager, app });
+        setupWebSocket(io, {
+            agentEngine,
+            messagingManager,
+            mcpClient,
+            scheduler,
+            memoryManager,
+            app
+        });
         app.locals.io = io;
 
         console.log('All services initialized');