squidclaw 1.0.0 → 1.2.0

package/lib/engine.js

@@ -1,7 +1,7 @@
 /**
- * Main entry point — starts all subsystems
+ * 🦑 Squidclaw Engine
+ * Clean middleware-based architecture
  */
-// Knowledge, tools, telegram — loaded dynamically
 
 import { loadConfig, getHome, ensureHome } from './core/config.js';
 import { initLogger, logger } from './core/logger.js';
@@ -13,6 +13,7 @@ import { ChannelHub } from './channels/hub.js';
 import { HeartbeatSystem } from './features/heartbeat.js';
 import { createAPIServer } from './api/server.js';
 import { addMediaSupport } from './channels/hub-media.js';
+import { MessagePipeline, createContext } from './middleware/pipeline.js';
 
 export class SquidclawEngine {
   constructor(options = {}) {
@@ -23,477 +24,263 @@ export class SquidclawEngine {
     this.aiGateway = null;
     this.agentManager = null;
     this.whatsappManager = null;
+    this.telegramManager = null;
     this.channelHub = null;
     this.heartbeat = null;
     this.server = null;
+    this.pipeline = null;
+    this.knowledgeBase = null;
+    this.toolRouter = null;
+    this.reminders = null;
+    this.autoMemory = null;
+    this.usageAlerts = null;
   }
 
+  // ──────────────────────────────────────────
+  // Pipeline Setup
+  // ──────────────────────────────────────────
+
+  async _buildPipeline() {
+    const pipeline = new MessagePipeline();
+
+    // Order matters! Each middleware runs in sequence.
+    const { allowlistMiddleware } = await import('./middleware/allowlist.js');
+    const { apiKeyDetectMiddleware } = await import('./middleware/api-key-detect.js');
+    const { commandsMiddleware } = await import('./middleware/commands.js');
+    const { mediaMiddleware } = await import('./middleware/media.js');
+    const { autoLinksMiddleware } = await import('./middleware/auto-links.js');
+    const { autoMemoryMiddleware } = await import('./middleware/auto-memory.js');
+    const { skillCheckMiddleware } = await import('./middleware/skill-check.js');
+    const { typingMiddleware } = await import('./middleware/typing.js');
+    const { aiProcessMiddleware } = await import('./middleware/ai-process.js');
+    const { usageAlertsMiddleware } = await import('./middleware/usage-alerts.js');
+    const { responseSenderMiddleware } = await import('./middleware/response-sender.js');
+
+    pipeline.use('allowlist', allowlistMiddleware);
+    pipeline.use('api-key-detect', apiKeyDetectMiddleware);
+    pipeline.use('commands', commandsMiddleware);
+    pipeline.use('media', mediaMiddleware);
+    pipeline.use('auto-links', autoLinksMiddleware);
+    pipeline.use('auto-memory', autoMemoryMiddleware);
+    pipeline.use('skill-check', skillCheckMiddleware);
+    pipeline.use('typing', typingMiddleware);        // wraps AI call with typing indicator
+    pipeline.use('ai-process', aiProcessMiddleware);
+    pipeline.use('usage-alerts', usageAlertsMiddleware);
+    pipeline.use('response-sender', responseSenderMiddleware);
+
+    return pipeline;
+  }
+
+  // ──────────────────────────────────────────
+  // Message Handler (used by both Telegram & WhatsApp)
+  // ──────────────────────────────────────────
+
+  async handleMessage(agentId, contactId, message, metadata) {
+    const agent = this.agentManager.get(agentId);
+    if (!agent) return;
+
+    const ctx = createContext(this, agentId, contactId, message, metadata);
+
+    try {
+      await this.pipeline.process(ctx);
+
+      // If pipeline short-circuited with a reply, send it
+      if (ctx.handled && ctx.response?.messages?.length > 0) {
+        if (ctx.platform === 'telegram' && this.telegramManager) {
+          await this.telegramManager.sendMessages(agentId, contactId, ctx.response.messages, metadata);
+        } else if (this.whatsappManager) {
+          for (const msg of ctx.response.messages) {
+            await this.whatsappManager.sendMessage(agentId, contactId, msg);
+          }
+        }
+      }
+    } catch (err) {
+      logger.error('engine', `Message handling error: ${err.message}`);
+      logger.error('engine', err.stack);
+    }
+  }
+
+  // ──────────────────────────────────────────
+  // Engine Startup
+  // ──────────────────────────────────────────
+
   async start() {
     ensureHome();
     initLogger(this.config.engine?.logLevel || 'info');
 
     console.log(`
-  🦑 Squidclaw Engine v0.1.0
+  🦑 Squidclaw Engine v1.1.0
   ──────────────────────────`);
 
     // 1. Storage
     const dbPath = this.config.storage?.sqlite?.path || `${this.home}/squidclaw.db`;
     this.storage = new SQLiteStorage(dbPath);
-    console.log(`  💾 Storage: SQLite (${dbPath})`);
+    console.log(`  💾 Storage: SQLite`);
 
     // 2. AI Gateway
     this.aiGateway = new AIGateway(this.config);
     const providers = Object.entries(this.config.ai?.providers || {})
-      .filter(([_, v]) => v.key)
-      .map(([k]) => k);
-    console.log(`  🧠 AI: ${providers.join(', ') || 'none configured'}`);
-    if (this.config.ai?.defaultModel) {
-      console.log(`  🎯 Default model: ${this.config.ai.defaultModel}`);
-    }
+      .filter(([_, v]) => v.key).map(([k]) => k);
+    console.log(`  🧠 AI: ${providers.join(', ') || 'none'}`);
+    if (this.config.ai?.defaultModel) console.log(`  🎯 Model: ${this.config.ai.defaultModel}`);
 
     // 3. Agent Manager
     this.agentManager = new AgentManager(this.storage, this.aiGateway);
     await this.agentManager.loadAll();
     const agents = this.agentManager.getAll();
-    console.log(`  👥 Agents: ${agents.length} loaded`);
+    console.log(`  👥 Agents: ${agents.length}`);
 
-    // 3b. Knowledge Base + Tools (optional)
-    try {
-      const { KnowledgeBase } = await import("./memory/knowledge.js");
-      const { ToolRouter } = await import("./tools/router.js");
-      const { addToolSupport } = await import("./core/agent-tools-mixin.js");
-      this.knowledgeBase = new KnowledgeBase(this.storage, this.config);
-      this.toolRouter = new ToolRouter(this.config, this.knowledgeBase);
-      const toolList = ["web search", "page reader"];
-      if (this.config.tools?.google?.oauthToken) toolList.push("calendar", "email");
-      console.log("  🔧 Tools: " + toolList.join(", "));
-      for (const agent of agents) {
-        addToolSupport(agent, this.toolRouter, this.knowledgeBase);
-      }
-    } catch (err) {
-      console.log("  🔧 Tools: basic mode");
-    }
+    // 4. Knowledge + Tools
+    await this._initTools(agents);
 
-    // 3e. Telegram Bot
-    if (this.config.channels?.telegram?.enabled && this.config.channels?.telegram?.token) {
-      try {
-        const { TelegramManager } = await import('./channels/telegram/bot.js');
-        this.telegramManager = new TelegramManager(this.config, this.agentManager);
-        
-        // Set up message handler
-        this.telegramManager.onMessage = async (agentId, contactId, message, metadata) => {
-          const agent = this.agentManager.get(agentId);
-          if (!agent) return;
-
-          // Allowlist check
-          const allowFrom = this.config.channels?.telegram?.allowFrom;
-          if (allowFrom && allowFrom !== '*') {
-            const senderId = contactId.replace('tg_', '');
-            const allowed = Array.isArray(allowFrom) ? allowFrom.includes(senderId) : String(allowFrom) === senderId;
-            if (!allowed) return;
-          }
-
-          // Handle API key detection — user pasting a key
-          const { detectApiKey, saveApiKey, getKeyConfirmation, detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('./features/self-config.js');
-          
-          const keyDetected = detectApiKey(message);
-          if (keyDetected && keyDetected.provider !== 'unknown') {
-            saveApiKey(keyDetected.provider, keyDetected.key);
-            // Reload config so skills see the new key
-            const { loadConfig } = await import('./core/config.js');
-            this.config = loadConfig();
-            const confirmation = getKeyConfirmation(keyDetected.provider);
-            await this.telegramManager.sendMessage(agentId, contactId, confirmation, metadata);
-            return;
-          }
+    // 5. Features (reminders, auto-memory, usage alerts)
+    await this._initFeatures();
 
-          // Handle /usage command
-          if (message.trim() === '/usage') {
-            try {
-              const { UsageAlerts } = await import('./features/usage-alerts.js');
-              const ua = new UsageAlerts(this.storage);
-              const summary = await ua.getSummary(agentId);
-              const fmtT = (n) => n >= 1e6 ? (n/1e6).toFixed(1)+'M' : n >= 1e3 ? (n/1e3).toFixed(1)+'K' : String(n);
-              const lines = [
-                '📊 *Usage Report*', '',
-                '*Today:*',
-                '  💬 ' + summary.today.calls + ' messages',
-                '  🪙 ' + fmtT(summary.today.tokens) + ' tokens',
-                '  💰 $' + summary.today.cost, '',
-                '*Last 30 days:*',
-                '  💬 ' + summary.month.calls + ' messages',
-                '  🪙 ' + fmtT(summary.month.tokens) + ' tokens',
-                '  💰 $' + summary.month.cost,
-              ];
-              await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
-            } catch (err) {
-              await this.telegramManager.sendMessage(agentId, contactId, '❌ ' + err.message, metadata);
-            }
-            return;
-          }
+    // 6. Message Pipeline
+    this.pipeline = await this._buildPipeline();
+    console.log(`  🔧 Pipeline: ${this.pipeline.middleware.length} middleware`);
 
-          // Handle /help command
-          if (message.trim() === '/help') {
-            const helpText = [
-              '🦑 *Commands*',
-              '',
-              '/status — model, uptime, usage stats',
-              '/backup — save me to a backup file',
-              '/memories — what I remember about you',
-              '/usage — spending report (today + 30 days)',
-              '/help — this message',
-              '',
-              'Just chat normally — I\'ll search the web, remember things, and help! 🦑',
-            ];
-            await this.telegramManager.sendMessage(agentId, contactId, helpText.join('\n'), metadata);
-            return;
-          }
+    // 7. Telegram
+    await this._initTelegram(agents);
 
-          // Handle /backup command
-          if (message.trim() === '/backup' || message.trim().toLowerCase() === 'backup yourself' || message.trim().toLowerCase().includes('backup')) {
-            if (message.toLowerCase().includes('backup') && (message.toLowerCase().includes('yourself') || message.toLowerCase().includes('your') || message.trim() === '/backup')) {
-              try {
-                const { AgentBackup } = await import('./features/backup.js');
-                const backup = await AgentBackup.create(agentId, this.home, this.storage);
-                const filename = (agent.name || agentId) + '_backup_' + new Date().toISOString().slice(0,10) + '.json';
-                const path = this.home + '/backups/' + filename;
-                const { mkdirSync } = await import('fs');
-                mkdirSync(this.home + '/backups', { recursive: true });
-                await AgentBackup.saveToFile(backup, path);
-                const size = (JSON.stringify(backup).length / 1024).toFixed(1);
-                const lines = [
-                  '💾 *Backup Complete!*',
-                  '',
-                  '📦 File: ' + filename,
-                  '📏 Size: ' + size + ' KB',
-                  '💬 Messages: ' + (backup.conversations?.length || 0),
-                  '🧠 Memories: ' + (backup.memories?.length || 0),
-                  '📄 Files: ' + Object.keys(backup.files).length,
-                  '',
-                  'I am safe! You can resurrect me anytime with this file 🦑',
-                ];
-                await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
-              } catch (err) {
-                await this.telegramManager.sendMessage(agentId, contactId, '❌ Backup failed: ' + err.message, metadata);
-              }
-              return;
-            }
-          }
+    // 8. WhatsApp
+    await this._initWhatsApp(agents);
 
-          // Handle /memories command
-          if (message.trim() === '/memories' || message.trim() === '/remember') {
-            try {
-              const memories = await this.storage.getMemories(agentId);
-              if (memories.length === 0) {
-                await this.telegramManager.sendMessage(agentId, contactId, '🧠 No memories yet. Tell me things and I\'ll remember!', metadata);
-              } else {
-                const memList = memories.slice(0, 20).map(m => '• ' + m.key + ': ' + m.value).join('\n');
-                await this.telegramManager.sendMessage(agentId, contactId, '🧠 *What I Remember*\n\n' + memList, metadata);
-              }
-            } catch (err) {
-              await this.telegramManager.sendMessage(agentId, contactId, '🧠 Memory error: ' + err.message, metadata);
-            }
-            return;
-          }
-
-          // Handle /status command
-          if (message.trim() === '/status' || message.trim().toLowerCase() === 'status') {
-            const uptime = process.uptime();
-            const h = Math.floor(uptime / 3600);
-            const m = Math.floor((uptime % 3600) / 60);
-            const usage = await this.storage.getUsage(agentId) || {};
-            const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
-            const fmtT = tokens >= 1000000 ? (tokens/1000000).toFixed(1)+'M' : tokens >= 1000 ? (tokens/1000).toFixed(1)+'K' : String(tokens);
-            const waOn = Object.values(this.whatsappManager?.getStatuses() || {}).some(s => s.connected);
-            
-            const lines = [
-              `🦑 *${agent.name || agentId} Status*`,
-              '────────────────────',
-              `🧠 Model: ${agent.model || 'unknown'}`,
-              `⏱️ Uptime: ${h}h ${m}m`,
-              `💬 Messages: ${usage.messages || 0}`,
-              `🪙 Tokens: ${fmtT}`,
-              `💰 Cost: $${(usage.cost_usd || 0).toFixed(4)}`,
-              '────────────────────',
-              `📱 WhatsApp: ${waOn ? '✅' : '❌'}`,
-              '✈️ Telegram: ✅ connected',
-              '────────────────────',
-              '⚡ Skills: search, reader, vision, voice, memory',
-              `🗣️ Language: ${agent.language || 'bilingual'}`,
-            ];
-            
-            await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
-            return;
-          }
-
-          // Process Telegram media (voice, images)
-          if (metadata._ctx && metadata.mediaType) {
-            try {
-              if (metadata.mediaType === 'audio') {
-                // Download and transcribe voice note
-                const file = await metadata._ctx.getFile();
-                const fileUrl = `https://api.telegram.org/file/bot${this.config.channels.telegram.token}/${file.file_path}`;
-                const resp = await fetch(fileUrl);
-                const buffer = Buffer.from(await resp.arrayBuffer());
-                
-                // Transcribe with Groq Whisper (free) or OpenAI
-                const groqKey = this.config.ai?.providers?.groq?.key;
-                const openaiKey = this.config.ai?.providers?.openai?.key;
-                const apiKey = groqKey || openaiKey;
-                const apiUrl = groqKey 
-                  ? 'https://api.groq.com/openai/v1/audio/transcriptions'
-                  : 'https://api.openai.com/v1/audio/transcriptions';
-                const model = groqKey ? 'whisper-large-v3' : 'whisper-1';
-
-                if (apiKey) {
-                  const form = new FormData();
-                  form.append('file', new Blob([buffer], { type: 'audio/ogg' }), 'voice.ogg');
-                  form.append('model', model);
-                  
-                  const tRes = await fetch(apiUrl, {
-                    method: 'POST',
-                    headers: { 'Authorization': 'Bearer ' + apiKey },
-                    body: form,
-                  });
-                  const tData = await tRes.json();
-                  if (tData.text) {
-                    message = '[Voice note]: "' + tData.text + '"';
-                    logger.info('telegram', 'Transcribed voice: ' + tData.text.slice(0, 50));
-                  }
-                }
-              } else if (metadata.mediaType === 'image') {
-                // Download and analyze image
-                const photos = metadata._ctx.message?.photo;
-                if (photos?.length > 0) {
-                  const photo = photos[photos.length - 1]; // highest res
-                  const file = await metadata._ctx.api.getFile(photo.file_id);
-                  const fileUrl = `https://api.telegram.org/file/bot${this.config.channels.telegram.token}/${file.file_path}`;
-                  const resp = await fetch(fileUrl);
-                  const buffer = Buffer.from(await resp.arrayBuffer());
-                  const base64 = buffer.toString('base64');
-                  
-                  // Analyze with Claude or OpenAI Vision
-                  const anthropicKey = this.config.ai?.providers?.anthropic?.key;
-                  const caption = message.replace('[📸 Image]', '').trim();
-                  const userPrompt = caption || 'What is in this image? Be concise.';
-                  
-                  if (anthropicKey) {
-                    const vRes = await fetch('https://api.anthropic.com/v1/messages', {
-                      method: 'POST',
-                      headers: {
-                        'x-api-key': anthropicKey,
-                        'content-type': 'application/json',
-                        'anthropic-version': '2023-06-01',
-                      },
-                      body: JSON.stringify({
-                        model: 'claude-sonnet-4-20250514',
-                        max_tokens: 300,
-                        messages: [{
-                          role: 'user',
-                          content: [
-                            { type: 'image', source: { type: 'base64', media_type: 'image/jpeg', data: base64 } },
-                            { type: 'text', text: userPrompt },
-                          ],
-                        }],
-                      }),
-                    });
-                    const vData = await vRes.json();
-                    const analysis = vData.content?.[0]?.text || '';
-                    if (analysis) {
-                      message = caption 
-                        ? '[Image with caption: "' + caption + '"] Image shows: ' + analysis
-                        : '[Image] Image shows: ' + analysis;
-                      logger.info('telegram', 'Analyzed image: ' + analysis.slice(0, 50));
-                    }
-                  }
-                }
-              } else if (metadata.mediaType === 'document') {
-                const file = await metadata._ctx.getFile();
-                const fileUrl = `https://api.telegram.org/file/bot${this.config.channels.telegram.token}/${file.file_path}`;
-                const resp = await fetch(fileUrl);
-                const buffer = Buffer.from(await resp.arrayBuffer());
-                const filename = message.match(/Document: (.+?)\]/)?.[1] || 'file.txt';
-                
-                try {
-                  const { DocIngester } = await import('./features/doc-ingest.js');
-                  const ingester = new DocIngester(this.storage, this.knowledgeBase, this.home);
-                  const result = await ingester.ingest(agentId, buffer, filename, metadata.mimeType);
-                  
-                  await this.telegramManager.sendMessage(agentId, contactId, 
-                    '📄 *Document absorbed!*\n📁 ' + filename + '\n📊 ' + result.chunks + ' chunks\n📝 ' + result.chars + ' chars\n\nI can answer questions about this! 🦑', metadata);
-                  return;
-                } catch (err) {
-                  message = '[Document: ' + filename + '] (Could not process: ' + err.message + ')';
-                }
-              }
-            } catch (err) {
-              logger.error('telegram', 'Media processing error: ' + err.message);
-            }
-          }
+    // 9. Channel Hub
+    this.channelHub = new ChannelHub(this.agentManager, this.whatsappManager, this.storage, this.telegramManager);
+    addMediaSupport(this.channelHub, this.config, this.home);
 
-          // Auto-read links in message
-          const linkRegex = /https?:\/\/[^\s<>"')\]]+/gi;
-          if (linkRegex.test(message) && this.toolRouter) {
-            try {
-              const { extractAndReadLinks } = await import('./features/auto-links.js');
-              const linkContext = await extractAndReadLinks(message, this.toolRouter.browser);
-              if (linkContext) {
-                metadata._linkContext = linkContext;
-              }
-            } catch {}
-          }
+    // 10. Heartbeat
+    this.heartbeat = new HeartbeatSystem(this.agentManager, this.whatsappManager, this.storage);
+    this.heartbeat.start();
+    console.log(`  💓 Heartbeat: active`);
 
-          // Check usage alerts
-          if (this.usageAlerts) {
-            try {
-              const alert = await this.usageAlerts.check(agentId);
-              if (alert.alert) {
-                await this.telegramManager.sendMessage(agentId, contactId, 
-                  '⚠️ *Usage Alert*\nYou have spent $' + alert.total + ' in the last 24h (threshold: $' + alert.threshold + ')', metadata);
-              }
-            } catch {}
-          }
+    // 11. API + Dashboard
+    await this._initAPI();
 
-          // Auto-extract facts from user message
-          if (this.autoMemory) {
-            try { await this.autoMemory.extract(agentId, contactId, message); } catch {}
-          }
+    // Graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
 
-          // Check if user is asking for a skill we don't have
-          const skillRequest = detectSkillRequest(message);
-          if (skillRequest) {
-            const availability = checkSkillAvailable(skillRequest, this.config);
-            if (!availability.available) {
-              const keyMsg = getKeyRequestMessage(skillRequest);
-              if (keyMsg) {
-                await this.telegramManager.sendMessage(agentId, contactId, keyMsg, metadata);
-                return;
-              }
-            }
-          }
+  // ──────────────────────────────────────────
+  // Init Helpers
+  // ──────────────────────────────────────────
 
-          // Show typing indicator while processing
-          const chatId = metadata.chatId || contactId.replace('tg_', '');
-          const botInfo = this.telegramManager?.bots?.get(agentId);
-          let typingInterval;
-          if (botInfo?.bot) {
-            const sendTyping = () => { try { botInfo.bot.api.sendChatAction(chatId, 'typing').catch(() => {}); } catch {} };
-            sendTyping();
-            typingInterval = setInterval(sendTyping, 4000);
-          }
+  async _initTools(agents) {
+    try {
+      const { KnowledgeBase } = await import('./memory/knowledge.js');
+      const { ToolRouter } = await import('./tools/router.js');
+      const { addToolSupport } = await import('./core/agent-tools-mixin.js');
+      
+      this.knowledgeBase = new KnowledgeBase(this.storage, this.config);
+      this.toolRouter = new ToolRouter(this.config, this.knowledgeBase);
 
-          let result;
-          try {
-            result = await agent.processMessage(contactId, message, metadata);
-          } finally {
-            if (typingInterval) clearInterval(typingInterval);
-          }
-          
-          if (result.reaction && metadata.messageId) {
-            try { await this.telegramManager.sendReaction(agentId, contactId, metadata.messageId, result.reaction, metadata); } catch {}
-          }
-          
-          if (result.messages && result.messages.length > 0) {
-            // Handle reminder if requested
-            if (result._reminder && this.reminders) {
-              const { time, message: remMsg } = result._reminder;
-              this.reminders.add(agentId, contactId, remMsg, time, 'telegram', metadata);
-            }
-
-            // Send image if generated
-            if (result.image) {
-              const photoData = result.image.url ? { url: result.image.url } : { base64: result.image.base64 };
-              const caption = result.messages?.[0] || '';
-              await this.telegramManager.sendPhoto(agentId, contactId, photoData, caption, metadata);
-            } else {
-              // Handle reminder if requested
-            if (result._reminder && this.reminders) {
-              const { time, message: remMsg } = result._reminder;
-              this.reminders.add(agentId, contactId, remMsg, time, 'telegram', metadata);
-            }
-
-            // Send image if generated
-            if (result.image) {
-              await this.telegramManager.sendPhoto(agentId, contactId, result.image, result.messages?.[0] || '', metadata);
-            } else if (metadata.originalType === 'voice' && result.messages.length === 1 && result.messages[0].length < 500) {
-              // Reply with voice when user sent voice
-              try {
-                const { VoiceReply } = await import('./features/voice-reply.js');
-                const vr = new VoiceReply(this.config);
-                const lang = /[\u0600-\u06FF]/.test(result.messages[0]) ? 'ar' : 'en';
-                const audio = await vr.generate(result.messages[0], { language: lang });
-                await this.telegramManager.sendVoice(agentId, contactId, audio, metadata);
-              } catch (err) {
-                // Fallback to text
-                logger.warn('voice', 'Voice reply failed, sending text: ' + err.message);
-                await this.telegramManager.sendMessages(agentId, contactId, result.messages, metadata);
-              }
-            } else {
-              await this.telegramManager.sendMessages(agentId, contactId, result.messages, metadata);
-            }
-            }
-          }
-        };
+      for (const agent of agents) {
+        addToolSupport(agent, this.toolRouter, this.knowledgeBase);
+      }
+      console.log('  🔧 Tools: active');
+    } catch (err) {
+      console.log('  🔧 Tools: basic');
+    }
+  }
 
-        // Start bot for all agents with telegram config
-        // Only start ONE bot instance (shared token = shared bot)
+  async _initFeatures() {
+    // Reminders
+    try {
+      const { ReminderManager } = await import('./features/reminders.js');
+      this.reminders = new ReminderManager(this.storage);
+      this.reminders.onFire = async (agentId, contactId, message, platform, metadata) => {
         try {
-          const firstAgent = agents[0];
-          if (firstAgent) {
-            await this.telegramManager.startBot(firstAgent.id, this.config.channels.telegram.token);
+          const msg = '⏰ *Reminder!*\n\n' + message;
+          if (platform === 'telegram' && this.telegramManager) {
+            await this.telegramManager.sendMessage(agentId, contactId, msg, metadata);
+          } else if (this.whatsappManager) {
+            await this.whatsappManager.sendMessage(agentId, contactId, msg);
           }
         } catch (err) {
-          console.log('  ✈️  Telegram: ' + err.message);
+          logger.error('reminder', 'Delivery failed: ' + err.message);
         }
-        console.log('  ✈️  Telegram: connected');
-      } catch (err) {
-        console.log('  ✈️  Telegram: failed (' + err.message + ')');
+      };
+      const pending = this.storage.db.prepare("SELECT COUNT(*) as c FROM reminders WHERE fired = 0 AND fire_at > datetime('now')").get();
+      if (pending.c > 0) console.log(`  ⏰ Reminders: ${pending.c} pending`);
+    } catch {}
+
+    // Auto-memory
+    try {
+      const { AutoMemory } = await import('./features/auto-memory.js');
+      this.autoMemory = new AutoMemory(this.storage);
+    } catch {}
+
+    // Usage alerts
+    try {
+      const { UsageAlerts } = await import('./features/usage-alerts.js');
+      this.usageAlerts = new UsageAlerts(this.storage);
+    } catch {}
+  }
+
+  async _initTelegram(agents) {
+    if (!this.config.channels?.telegram?.enabled || !this.config.channels?.telegram?.token) return;
+
+    try {
+      const { TelegramManager } = await import('./channels/telegram/bot.js');
+      this.telegramManager = new TelegramManager(this.config, this.agentManager);
+
+      // Route all messages through the pipeline
+      this.telegramManager.onMessage = (agentId, contactId, message, metadata) => {
+        metadata.platform = 'telegram';
+        metadata.chatId = metadata.chatId || contactId.replace('tg_', '');
+        return this.handleMessage(agentId, contactId, message, metadata);
+      };
+
+      const firstAgent = agents[0];
+      if (firstAgent) {
+        await this.telegramManager.startBot(firstAgent.id, this.config.channels.telegram.token);
       }
+      console.log('  ✈️  Telegram: connected');
+    } catch (err) {
+      console.log('  ✈️  Telegram: ' + err.message);
     }
+  }
 
-    // 4. WhatsApp Manager
+  async _initWhatsApp(agents) {
     this.whatsappManager = new WhatsAppManager(this.config, this.agentManager, this.home);
 
-    // Start WhatsApp sessions for all agents that have them configured
     for (const agent of agents) {
       if (agent.status === 'active' && agent.whatsappNumber) {
-        try {
-          await this.whatsappManager.startSession(agent.id);
-        } catch (err) {
-          logger.warn('engine', `Failed to start WhatsApp for "${agent.name}": ${err.message}`);
+        try { await this.whatsappManager.startSession(agent.id); } catch (err) {
+          logger.warn('engine', `WhatsApp for "${agent.name}": ${err.message}`);
         }
       }
     }
+
     const waStatuses = this.whatsappManager.getStatuses();
     const connected = Object.values(waStatuses).filter(s => s.connected).length;
-    console.log(`  📱 WhatsApp: ${connected}/${agents.length} connected`);
-
-    // 5. Channel Hub
-    this.channelHub = new ChannelHub(this.agentManager, this.whatsappManager, this.storage, this.telegramManager);
-    addMediaSupport(this.channelHub, this.config, this.home);
-
-    // 6. Heartbeat
-    this.heartbeat = new HeartbeatSystem(this.agentManager, this.whatsappManager, this.storage);
-    this.heartbeat.start();
-    console.log(`  💓 Heartbeat: active`);
+    console.log(`  📱 WhatsApp: ${connected}/${agents.length}`);
+  }
 
-    // 7. API Server + Dashboard
+  async _initAPI() {
     const app = createAPIServer(this);
-    try { const { addDashboardRoutes } = await import('./api/dashboard.js'); addDashboardRoutes(app, this); } catch {}
+    try {
+      const { addDashboardRoutes } = await import('./api/dashboard.js');
+      addDashboardRoutes(app, this);
+    } catch {}
+
     this.server = app.listen(this.port, this.config.engine?.bind || '0.0.0.0', () => {
-      console.log(`  🌐 API: http://${this.config.engine?.bind || '0.0.0.0'}:${this.port}`);
+      console.log(`  🌐 API: http://0.0.0.0:${this.port}`);
       console.log(`  ──────────────────────────`);
       console.log(`  ✅ Engine running!\n`);
     });
-
-    // Graceful shutdown
-    process.on('SIGINT', () => this.stop());
-    process.on('SIGTERM', () => this.stop());
   }
 
+  // ──────────────────────────────────────────
+  // Shutdown
+  // ──────────────────────────────────────────
+
   async stop() {
     console.log('\n  🦑 Shutting down...');
     this.heartbeat?.stop();
+    this.reminders?.destroy();
     await this.whatsappManager?.stopAll();
     this.storage?.close();
     this.server?.close();