squidclaw 1.4.0 → 2.0.0

package/lib/engine.js

@@ -62,10 +62,16 @@ export class SquidclawEngine {
     pipeline.use('media', mediaMiddleware);
     pipeline.use('auto-links', autoLinksMiddleware);
     pipeline.use('auto-memory', autoMemoryMiddleware);
+    const { configChatMiddleware } = await import('./middleware/config-chat.js');
+    pipeline.use('config-chat', configChatMiddleware);
     pipeline.use('skill-check', skillCheckMiddleware);
     pipeline.use('typing', typingMiddleware);        // wraps AI call with typing indicator
     pipeline.use('ai-process', aiProcessMiddleware);
+    const { proactiveMiddleware } = await import('./middleware/proactive.js');
+    const { learningMiddleware } = await import('./middleware/learning.js');
     pipeline.use('usage-alerts', usageAlertsMiddleware);
+    pipeline.use('proactive', proactiveMiddleware);
+    pipeline.use('learning', learningMiddleware);
     pipeline.use('response-sender', responseSenderMiddleware);
 
     return pipeline;
@@ -136,7 +142,13 @@ export class SquidclawEngine {
     // 5. Features (reminders, auto-memory, usage alerts)
     await this._initFeatures();
 
-    // 5b. Sub-agents
+    // 5b. Config Manager
+    try {
+      const { ConfigManager } = await import('./features/config-manager.js');
+      this.configManager = new ConfigManager(this);
+    } catch {}
+
+    // 5c. Sub-agents
     try {
       const { SubAgentManager } = await import('./features/sub-agents.js');
       this.subAgents = new SubAgentManager(this);
@@ -183,6 +195,7 @@ export class SquidclawEngine {
       this.knowledgeBase = new KnowledgeBase(this.storage, this.config);
       this.toolRouter = new ToolRouter(this.config, this.knowledgeBase);
 
+      this.toolRouter.setContext(this, this.aiGateway, this.config.ai?.defaultModel);
       for (const agent of agents) {
         addToolSupport(agent, this.toolRouter, this.knowledgeBase);
       }

package/lib/features/config-manager.js

@@ -0,0 +1,238 @@
+/**
+ * 🦑 Config Manager
+ * Hot reload, chat commands, .env support, profiles, validation
+ */
+
+import { loadConfig, saveConfig, getHome } from '../core/config.js';
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../core/logger.js';
+
+export class ConfigManager {
+  constructor(engine) {
+    this.engine = engine;
+    this.home = getHome();
+    this._loadEnv();
+    this._watchConfig();
+  }
+
+  // ── .env support ──
+
+  _loadEnv() {
+    const envPath = join(this.home, '.env');
+    if (!existsSync(envPath)) return;
+
+    try {
+      const lines = readFileSync(envPath, 'utf8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+        process.env[key] = value;
+      }
+      logger.info('config', 'Loaded .env file');
+    } catch {}
+  }
+
+  // ── Hot reload ──
+
+  _watchConfig() {
+    const configPath = join(this.home, 'config.json');
+    try {
+      const { watch } = require('fs');
+      let debounce = null;
+      watch(configPath, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(() => {
+          try {
+            this.engine.config = loadConfig();
+            logger.info('config', 'Config hot-reloaded');
+          } catch (err) {
+            logger.error('config', 'Hot reload failed: ' + err.message);
+          }
+        }, 1000);
+      });
+    } catch {
+      // fs.watch not available — use polling
+      this._pollConfig(configPath);
+    }
+  }
+
+  _pollConfig(configPath) {
+    let lastMtime = 0;
+    try { lastMtime = readFileSync(configPath).length; } catch {}
+    
+    setInterval(() => {
+      try {
+        const content = readFileSync(configPath, 'utf8');
+        if (content.length !== lastMtime) {
+          lastMtime = content.length;
+          this.engine.config = loadConfig();
+          logger.info('config', 'Config hot-reloaded (poll)');
+        }
+      } catch {}
+    }, 5000);
+  }
+
+  // ── Set config value ──
+
+  set(path, value) {
+    const config = loadConfig();
+    const parts = path.split('.');
+    let obj = config;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!obj[parts[i]]) obj[parts[i]] = {};
+      obj = obj[parts[i]];
+    }
+
+    // Auto-convert types
+    if (value === 'true') value = true;
+    else if (value === 'false') value = false;
+    else if (!isNaN(value) && value !== '') value = Number(value);
+
+    obj[parts[parts.length - 1]] = value;
+    saveConfig(config);
+    this.engine.config = config;
+
+    logger.info('config', `Set ${path} = ${JSON.stringify(value)}`);
+    return { path, value };
+  }
+
+  // ── Get config value ──
+
+  get(path) {
+    const config = loadConfig();
+    const parts = path.split('.');
+    let obj = config;
+
+    for (const part of parts) {
+      if (obj === undefined) return undefined;
+      obj = obj[part];
+    }
+
+    return obj;
+  }
+
+  // ── Profiles ──
+
+  saveProfile(name) {
+    const configPath = join(this.home, 'config.json');
+    const profilePath = join(this.home, `config.${name}.json`);
+    copyFileSync(configPath, profilePath);
+    return profilePath;
+  }
+
+  loadProfile(name) {
+    const profilePath = join(this.home, `config.${name}.json`);
+    if (!existsSync(profilePath)) throw new Error('Profile not found: ' + name);
+    
+    const configPath = join(this.home, 'config.json');
+    copyFileSync(profilePath, configPath);
+    this.engine.config = loadConfig();
+    return true;
+  }
+
+  listProfiles() {
+    const { readdirSync } = require('fs');
+    return readdirSync(this.home)
+      .filter(f => f.startsWith('config.') && f.endsWith('.json') && f !== 'config.json')
+      .map(f => f.replace('config.', '').replace('.json', ''));
+  }
+
+  // ── Validation ──
+
+  async validate() {
+    const config = loadConfig();
+    const results = [];
+
+    // Check AI providers
+    const providers = config.ai?.providers || {};
+    for (const [name, prov] of Object.entries(providers)) {
+      if (!prov.key || prov.key === 'local') continue;
+      
+      try {
+        const valid = await this._testProvider(name, prov.key);
+        results.push({ name, status: valid ? '✅' : '❌', message: valid ? 'Valid' : 'Invalid key' });
+      } catch (err) {
+        results.push({ name, status: '❌', message: err.message });
+      }
+    }
+
+    // Check Telegram
+    if (config.channels?.telegram?.token) {
+      try {
+        const res = await fetch(`https://api.telegram.org/bot${config.channels.telegram.token}/getMe`);
+        const data = await res.json();
+        results.push({ name: 'Telegram', status: data.ok ? '✅' : '❌', message: data.ok ? '@' + data.result.username : 'Invalid token' });
+      } catch (err) {
+        results.push({ name: 'Telegram', status: '❌', message: err.message });
+      }
+    }
+
+    // Check agents
+    const agentsDir = join(this.home, 'agents');
+    if (existsSync(agentsDir)) {
+      const { readdirSync } = require('fs');
+      const count = readdirSync(agentsDir, { withFileTypes: true }).filter(d => d.isDirectory()).length;
+      results.push({ name: 'Agents', status: '✅', message: count + ' configured' });
+    }
+
+    return results;
+  }
+
+  async _testProvider(name, key) {
+    const urls = {
+      anthropic: 'https://api.anthropic.com/v1/models',
+      openai: 'https://api.openai.com/v1/models',
+      google: `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`,
+      groq: 'https://api.groq.com/openai/v1/models',
+    };
+
+    const url = urls[name];
+    if (!url) return true; // Can't validate, assume OK
+
+    const headers = {};
+    if (name === 'anthropic') {
+      headers['x-api-key'] = key;
+      headers['anthropic-version'] = '2023-06-01';
+    } else if (name !== 'google') {
+      headers['Authorization'] = 'Bearer ' + key;
+    }
+
+    const res = await fetch(url, { headers });
+    return res.ok;
+  }
+
+  // ── Chat command parsing ──
+
+  static parseConfigCommand(message) {
+    const lower = message.toLowerCase().trim();
+
+    // "switch to gpt-4o" / "use gemini"
+    const modelMatch = lower.match(/(?:switch|change|use)\s+(?:to\s+)?(?:model\s+)?(.+)/);
+    if (modelMatch) {
+      const model = modelMatch[1].trim();
+      // Map common names to actual model IDs
+      const aliases = {
+        'gpt4': 'gpt-4o', 'gpt-4': 'gpt-4o', 'gpt4o': 'gpt-4o',
+        'claude': 'claude-sonnet-4-20250514', 'sonnet': 'claude-sonnet-4-20250514',
+        'opus': 'claude-opus-4', 'haiku': 'claude-haiku-3-5',
+        'gemini': 'gemini-2.5-flash', 'flash': 'gemini-2.5-flash',
+        'llama': 'llama-3.3-70b-versatile', 'deepseek': 'deepseek-chat',
+      };
+      return { action: 'set_model', model: aliases[model] || model };
+    }
+
+    // "set temperature to 0.8"
+    const setMatch = lower.match(/set\s+(\w[\w.]*)\s+(?:to\s+)?(.+)/);
+    if (setMatch) {
+      return { action: 'set', path: setMatch[1], value: setMatch[2] };
+    }
+
+    return null;
+  }
+}

package/lib/features/conversation-summary.js

@@ -0,0 +1,15 @@
+import { logger } from '../core/logger.js';
+
+export async function summarizeConversation(storage, aiGateway, agentId, contactId, model) {
+  const messages = await storage.getConversation(agentId, contactId, 100);
+  if (messages.length === 0) return 'No conversation to summarize.';
+
+  const chatText = messages.map(m => `${m.role}: ${m.content}`).join('\n');
+
+  const response = await aiGateway.chat([
+    { role: 'system', content: 'Summarize this conversation concisely. Include key decisions, action items, and important information discussed. Be brief.' },
+    { role: 'user', content: chatText },
+  ], { model });
+
+  return response.content;
+}

package/lib/features/daily-briefing.js

@@ -0,0 +1,48 @@
+import { logger } from '../core/logger.js';
+
+export async function generateBriefing(engine, agentId) {
+  const parts = [];
+
+  // Weather (default Riyadh)
+  try {
+    const { getWeather } = await import('../tools/weather.js');
+    parts.push(await getWeather('Riyadh'));
+  } catch {}
+
+  // Pending tasks
+  try {
+    const { TaskManager } = await import('../tools/tasks.js');
+    const tm = new TaskManager(engine.storage);
+    // Get all contacts' tasks for this agent
+    const tasks = engine.storage.db.prepare('SELECT * FROM tasks WHERE agent_id = ? AND done = 0 ORDER BY created_at LIMIT 10').all(agentId);
+    if (tasks.length > 0) {
+      parts.push('📋 *Pending Tasks:*\n' + tasks.map((t, i) => (i+1) + '. ' + t.task).join('\n'));
+    }
+  } catch {}
+
+  // Pending reminders
+  try {
+    const reminders = engine.storage.db.prepare("SELECT * FROM reminders WHERE agent_id = ? AND fired = 0 AND fire_at > datetime('now') ORDER BY fire_at LIMIT 5").all(agentId);
+    if (reminders.length > 0) {
+      parts.push('⏰ *Upcoming Reminders:*\n' + reminders.map(r => '• ' + r.fire_at.slice(11, 16) + ' — ' + r.message).join('\n'));
+    }
+  } catch {}
+
+  // Memories count
+  try {
+    const memCount = engine.storage.db.prepare('SELECT COUNT(*) as c FROM memories WHERE agent_id = ?').get(agentId);
+    parts.push('🧠 Memories: ' + (memCount?.c || 0) + ' facts stored');
+  } catch {}
+
+  // News
+  try {
+    const { BrowserTool } = await import('../tools/browser.js');
+    const b = new BrowserTool({});
+    const news = await b.search('Saudi Arabia news today', 3);
+    if (news.length > 0) {
+      parts.push('📰 *Top News:*\n' + news.map(n => '• ' + n.title).join('\n'));
+    }
+  } catch {}
+
+  return '☀️ *Good Morning! Daily Briefing*\n\n' + parts.join('\n\n');
+}

package/lib/features/handoff.js

@@ -0,0 +1,31 @@
+import { logger } from '../core/logger.js';
+
+export class HandoffManager {
+  constructor(storage) {
+    this.storage = storage;
+    this.activeHandoffs = new Map(); // contactId -> { to, startedAt }
+  }
+
+  start(agentId, contactId, to, reason) {
+    this.activeHandoffs.set(contactId, {
+      to, reason, startedAt: new Date(), agentId
+    });
+    logger.info('handoff', `${contactId} → ${to}: ${reason}`);
+    return true;
+  }
+
+  isActive(contactId) {
+    return this.activeHandoffs.has(contactId);
+  }
+
+  end(contactId) {
+    this.activeHandoffs.delete(contactId);
+    return true;
+  }
+
+  getActive() {
+    return Array.from(this.activeHandoffs.entries()).map(([id, h]) => ({
+      contactId: id, ...h
+    }));
+  }
+}

package/lib/features/scheduled-reports.js

@@ -0,0 +1,47 @@
+import { logger } from '../core/logger.js';
+
+export class ScheduledReports {
+  constructor(engine) {
+    this.engine = engine;
+    this.timers = [];
+  }
+
+  startWeeklyReport(agentId, contactId, platform, metadata) {
+    // Every Sunday at 9 AM UTC
+    const check = () => {
+      const now = new Date();
+      if (now.getDay() === 0 && now.getHours() === 9 && now.getMinutes() === 0) {
+        this._sendWeeklyReport(agentId, contactId, platform, metadata);
+      }
+    };
+    const timer = setInterval(check, 60000);
+    this.timers.push(timer);
+  }
+
+  async _sendWeeklyReport(agentId, contactId, platform, metadata) {
+    try {
+      const usage = this.engine.storage.db.prepare(
+        "SELECT COUNT(*) as msgs, SUM(cost_usd) as cost, SUM(input_tokens + output_tokens) as tokens FROM usage WHERE agent_id = ? AND created_at >= date('now', '-7 days')"
+      ).get(agentId);
+
+      const fmtT = (n) => n >= 1e6 ? (n/1e6).toFixed(1)+'M' : n >= 1e3 ? (n/1e3).toFixed(1)+'K' : String(n || 0);
+      
+      const report = [
+        '📊 *Weekly Report*', '',
+        '💬 Messages: ' + (usage?.msgs || 0),
+        '🪙 Tokens: ' + fmtT(usage?.tokens),
+        '💰 Cost: $' + (usage?.cost || 0).toFixed(4),
+      ].join('\n');
+
+      if (platform === 'telegram' && this.engine.telegramManager) {
+        await this.engine.telegramManager.sendMessage(agentId, contactId, report, metadata);
+      }
+    } catch (err) {
+      logger.error('reports', 'Weekly report failed: ' + err.message);
+    }
+  }
+
+  stop() {
+    this.timers.forEach(t => clearInterval(t));
+  }
+}

package/lib/features/webhooks.js

@@ -0,0 +1,55 @@
+import { logger } from '../core/logger.js';
+
+export class WebhookManager {
+  constructor(storage) {
+    this.storage = storage;
+    this._initDb();
+  }
+
+  _initDb() {
+    try {
+      this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS webhooks (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          url TEXT NOT NULL,
+          event TEXT DEFAULT 'message',
+          active INTEGER DEFAULT 1,
+          created_at TEXT DEFAULT (datetime('now'))
+        )
+      `);
+    } catch {}
+  }
+
+  add(agentId, name, url, event = 'message') {
+    const id = 'wh_' + Date.now().toString(36);
+    this.storage.db.prepare('INSERT INTO webhooks (id, agent_id, name, url, event) VALUES (?, ?, ?, ?, ?)').run(id, agentId, name, url, event);
+    return id;
+  }
+
+  async fire(agentId, event, data) {
+    const hooks = this.storage.db.prepare('SELECT * FROM webhooks WHERE agent_id = ? AND event = ? AND active = 1').all(agentId, event);
+    
+    for (const hook of hooks) {
+      try {
+        await fetch(hook.url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ event, agentId, data, timestamp: new Date().toISOString() }),
+        });
+        logger.info('webhooks', `Fired ${hook.name} → ${hook.url}`);
+      } catch (err) {
+        logger.error('webhooks', `Failed ${hook.name}: ${err.message}`);
+      }
+    }
+  }
+
+  list(agentId) {
+    return this.storage.db.prepare('SELECT * FROM webhooks WHERE agent_id = ?').all(agentId);
+  }
+
+  remove(id) {
+    this.storage.db.prepare('DELETE FROM webhooks WHERE id = ?').run(id);
+  }
+}

package/lib/middleware/commands.js

@@ -16,7 +16,14 @@ export async function commandsMiddleware(ctx, next) {
       '/memories — what I remember about you',
       '/tasks — your todo list',
       '/usage — spending report',
-      '/exec <cmd> — run a shell command',
+      '/notes — notes',
+              '/contacts — contact book',
+              '/briefing — daily briefing',
+              '/summary — summarize chat',
+              '/trivia — trivia game',
+              '/flip — coin flip',
+              '/config — manage settings',
+              '/exec <cmd> — run a shell command',
               '/files — list sandbox files',
               '/subagents — list background tasks',
               '/help — this message',
@@ -120,6 +127,151 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/notes') {
+    try {
+      const { NotesManager } = await import('../tools/notes.js');
+      const nm = new NotesManager(ctx.storage);
+      const args = msg.slice(7).trim();
+      if (args) {
+        nm.add(ctx.agentId, ctx.contactId, args);
+        await ctx.reply('📝 Note saved!');
+      } else {
+        const notes = nm.list(ctx.agentId, ctx.contactId);
+        if (notes.length === 0) await ctx.reply('📝 No notes yet. Use /notes <text> to add one.');
+        else await ctx.reply('📝 *Your Notes*\n\n' + notes.map((n, i) => (i+1) + '. ' + n.content.slice(0, 80)).join('\n'));
+      }
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/contacts') {
+    try {
+      const { ContactBook } = await import('../tools/contacts.js');
+      const cb = new ContactBook(ctx.storage);
+      const args = msg.slice(10).trim();
+      if (args) {
+        const found = cb.find(ctx.agentId, ctx.contactId, args);
+        if (found.length === 0) await ctx.reply('📇 No contacts found for: ' + args);
+        else await ctx.reply('📇 *Contacts*\n\n' + found.map(c => '• ' + c.name + (c.phone ? ' — ' + c.phone : '')).join('\n'));
+      } else {
+        const all = cb.list(ctx.agentId, ctx.contactId);
+        if (all.length === 0) await ctx.reply('📇 No contacts saved yet.');
+        else await ctx.reply('📇 *Contact Book*\n\n' + all.map(c => '• ' + c.name + (c.phone ? ' — ' + c.phone : '')).join('\n'));
+      }
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/briefing') {
+    try {
+      const { generateBriefing } = await import('../features/daily-briefing.js');
+      const briefing = await generateBriefing(ctx.engine, ctx.agentId);
+      await ctx.reply(briefing);
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/summary') {
+    try {
+      const { summarizeConversation } = await import('../features/conversation-summary.js');
+      const summary = await summarizeConversation(ctx.storage, ctx.engine.aiGateway, ctx.agentId, ctx.contactId, ctx.agent?.model);
+      await ctx.reply('📋 *Conversation Summary*\n\n' + summary);
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/flip') {
+    const { coinFlip } = await import('../tools/games.js');
+    await ctx.reply(coinFlip());
+    return;
+  }
+
+  if (cmd === '/roll') {
+    const { rollDice } = await import('../tools/games.js');
+    const sides = parseInt(msg.slice(6)) || 6;
+    await ctx.reply('🎲 ' + rollDice(sides));
+    return;
+  }
+
+  if (cmd === '/trivia') {
+    const { getTrivia } = await import('../tools/games.js');
+    const t = getTrivia();
+    await ctx.reply('🎯 *Trivia!*\n\n' + t.q);
+    return;
+  }
+
+  if (cmd === '/riddle') {
+    const { getRiddle } = await import('../tools/games.js');
+    const r = getRiddle();
+    await ctx.reply('🧩 ' + r.q);
+    return;
+  }
+
+  if (cmd === '/config') {
+    const args = msg.slice(8).trim();
+    if (!args || args === 'help') {
+      await ctx.reply([
+        '⚙️ *Config Commands*', '',
+        '/config get <path> — show value',
+        '/config set <path> <value> — set value',
+        '/config test — validate all connections',
+        '/config profiles — list saved profiles',
+        '/config save <name> — save current config',
+        '/config load <name> — switch profile',
+        '', 'Or just say: "switch to gemini" 🦑',
+      ].join('\n'));
+      return;
+    }
+
+    const cm = ctx.engine.configManager;
+    if (!cm) { await ctx.reply('❌ Config manager not available'); return; }
+
+    if (args.startsWith('get ')) {
+      const val = cm.get(args.slice(4).trim());
+      await ctx.reply('⚙️ ' + args.slice(4).trim() + ' = ' + JSON.stringify(val));
+      return;
+    }
+
+    if (args.startsWith('set ')) {
+      const parts = args.slice(4).trim().split(/\s+/);
+      const path = parts[0];
+      const value = parts.slice(1).join(' ');
+      cm.set(path, value);
+      await ctx.reply('✅ Set *' + path + '* = ' + value);
+      return;
+    }
+
+    if (args === 'test' || args === 'validate') {
+      await ctx.reply('🔍 Validating connections...');
+      const results = await cm.validate();
+      const lines = results.map(r => r.status + ' *' + r.name + '* — ' + r.message);
+      await ctx.reply('⚙️ *Config Validation*\n\n' + lines.join('\n'));
+      return;
+    }
+
+    if (args === 'profiles') {
+      const profiles = cm.listProfiles();
+      await ctx.reply(profiles.length ? '📋 Profiles: ' + profiles.join(', ') : '📋 No saved profiles');
+      return;
+    }
+
+    if (args.startsWith('save ')) {
+      cm.saveProfile(args.slice(5).trim());
+      await ctx.reply('✅ Profile saved: ' + args.slice(5).trim());
+      return;
+    }
+
+    if (args.startsWith('load ')) {
+      try {
+        cm.loadProfile(args.slice(5).trim());
+        await ctx.reply('✅ Profile loaded: ' + args.slice(5).trim() + '\n⚠️ Restart recommended');
+      } catch (err) {
+        await ctx.reply('❌ ' + err.message);
+      }
+      return;
+    }
+  }
+
   if (cmd === '/exec') {
     const command = msg.slice(6).trim();
     if (!command) { await ctx.reply('Usage: /exec <command>'); return; }

package/lib/middleware/config-chat.js

@@ -0,0 +1,35 @@
+/**
+ * Handle config changes via natural language
+ * "switch to gemini", "use gpt-4o", "set temperature to 0.8"
+ */
+import { logger } from '../core/logger.js';
+
+export async function configChatMiddleware(ctx, next) {
+  if (!ctx.engine.configManager) { await next(); return; }
+
+  const { ConfigManager } = await import('../features/config-manager.js');
+  const parsed = ConfigManager.parseConfigCommand(ctx.message);
+  
+  if (!parsed) { await next(); return; }
+
+  try {
+    if (parsed.action === 'set_model') {
+      ctx.engine.configManager.set('ai.defaultModel', parsed.model);
+      // Update agent's model too
+      if (ctx.agent) ctx.agent.model = parsed.model;
+      await ctx.reply('✅ Model switched to *' + parsed.model + '*\n\nI will use this model from now on 🦑');
+      return;
+    }
+
+    if (parsed.action === 'set') {
+      ctx.engine.configManager.set(parsed.path, parsed.value);
+      await ctx.reply('✅ Set *' + parsed.path + '* = ' + parsed.value);
+      return;
+    }
+  } catch (err) {
+    await ctx.reply('❌ Config error: ' + err.message);
+    return;
+  }
+
+  await next();
+}

package/lib/middleware/learning.js

@@ -0,0 +1,33 @@
+/**
+ * Learning mode — track preferences and patterns
+ */
+import { logger } from '../core/logger.js';
+
+export async function learningMiddleware(ctx, next) {
+  // Track interaction patterns
+  try {
+    const hour = new Date().getHours();
+    const key = 'active_hours_' + (hour < 10 ? '0' : '') + hour;
+    
+    // Increment activity counter for this hour
+    const existing = ctx.storage.db.prepare(
+      'SELECT value FROM memories WHERE agent_id = ? AND key = ?'
+    ).get(ctx.agentId, key);
+    
+    const count = existing ? parseInt(existing.value) + 1 : 1;
+    await ctx.storage.saveMemory(ctx.agentId, key, String(count), 'pattern');
+    
+    // Track language preference
+    const hasArabic = /[\u0600-\u06FF]/.test(ctx.message);
+    if (hasArabic) {
+      await ctx.storage.saveMemory(ctx.agentId, 'prefers_arabic', 'true', 'pattern');
+    }
+    
+    // Track message length preference
+    if (ctx.message.length < 20) {
+      await ctx.storage.saveMemory(ctx.agentId, 'prefers_short_messages', 'true', 'pattern');
+    }
+  } catch {}
+
+  await next();
+}

package/lib/middleware/proactive.js

@@ -0,0 +1,22 @@
+/**
+ * Proactive check-ins — notify about upcoming events
+ */
+export async function proactiveMiddleware(ctx, next) {
+  await next();
+  
+  // After responding, check if there are upcoming reminders (< 1 hour)
+  if (!ctx.engine.reminders) return;
+  
+  try {
+    const upcoming = ctx.engine.storage.db.prepare(
+      "SELECT * FROM reminders WHERE agent_id = ? AND contact_id = ? AND fired = 0 AND fire_at BETWEEN datetime('now') AND datetime('now', '+1 hour') LIMIT 1"
+    ).get(ctx.agentId, ctx.contactId);
+    
+    if (upcoming && ctx.response?.messages) {
+      const mins = Math.round((new Date(upcoming.fire_at + 'Z') - Date.now()) / 60000);
+      if (mins > 0 && mins <= 60) {
+        ctx.response.messages.push('⏰ Heads up — you have a reminder in ' + mins + ' minutes: ' + upcoming.message);
+      }
+    }
+  } catch {}
+}

package/lib/tools/contacts.js

@@ -0,0 +1,44 @@
+import { logger } from '../core/logger.js';
+
+export class ContactBook {
+  constructor(storage) {
+    this.storage = storage;
+    this._initDb();
+  }
+
+  _initDb() {
+    try {
+      this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS contact_book (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          agent_id TEXT NOT NULL,
+          owner_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          phone TEXT,
+          email TEXT,
+          notes TEXT DEFAULT '',
+          created_at TEXT DEFAULT (datetime('now'))
+        )
+      `);
+    } catch {}
+  }
+
+  add(agentId, ownerId, name, phone, email, notes) {
+    this.storage.db.prepare('INSERT INTO contact_book (agent_id, owner_id, name, phone, email, notes) VALUES (?, ?, ?, ?, ?, ?)')
+      .run(agentId, ownerId, name, phone || null, email || null, notes || '');
+    return true;
+  }
+
+  find(agentId, ownerId, query) {
+    return this.storage.db.prepare('SELECT * FROM contact_book WHERE agent_id = ? AND owner_id = ? AND (name LIKE ? OR phone LIKE ? OR email LIKE ?) LIMIT 10')
+      .all(agentId, ownerId, `%${query}%`, `%${query}%`, `%${query}%`);
+  }
+
+  list(agentId, ownerId) {
+    return this.storage.db.prepare('SELECT * FROM contact_book WHERE agent_id = ? AND owner_id = ? ORDER BY name').all(agentId, ownerId);
+  }
+
+  delete(agentId, id) {
+    this.storage.db.prepare('DELETE FROM contact_book WHERE id = ? AND agent_id = ?').run(id, agentId);
+  }
+}

package/lib/tools/games.js

@@ -0,0 +1,44 @@
+import crypto from 'crypto';
+
+const TRIVIA = [
+  { q: 'What is the capital of Saudi Arabia?', a: 'Riyadh' },
+  { q: 'In what year was the iPhone first released?', a: '2007' },
+  { q: 'What planet is known as the Red Planet?', a: 'Mars' },
+  { q: 'How many legs does an octopus have?', a: '8' },
+  { q: 'What is the largest ocean on Earth?', a: 'Pacific Ocean' },
+  { q: 'Who painted the Mona Lisa?', a: 'Leonardo da Vinci' },
+  { q: 'What is the chemical symbol for gold?', a: 'Au' },
+  { q: 'What year did World War II end?', a: '1945' },
+  { q: 'What is the tallest building in the world?', a: 'Burj Khalifa' },
+  { q: 'How many continents are there?', a: '7' },
+];
+
+const RIDDLES = [
+  { q: 'I have cities, but no houses. I have mountains, but no trees. What am I?', a: 'A map' },
+  { q: 'What has hands but cannot clap?', a: 'A clock' },
+  { q: 'I speak without a mouth and hear without ears. What am I?', a: 'An echo' },
+  { q: 'The more you take, the more you leave behind. What am I?', a: 'Footsteps' },
+  { q: 'What can you break, even if you never pick it up or touch it?', a: 'A promise' },
+];
+
+export function getTrivia() {
+  const i = crypto.randomInt(TRIVIA.length);
+  return TRIVIA[i];
+}
+
+export function getRiddle() {
+  const i = crypto.randomInt(RIDDLES.length);
+  return RIDDLES[i];
+}
+
+export function coinFlip() {
+  return crypto.randomInt(2) === 0 ? 'Heads! 🪙' : 'Tails! 🪙';
+}
+
+export function rollDice(sides = 6) {
+  return crypto.randomInt(sides) + 1;
+}
+
+export function randomNumber(min = 1, max = 100) {
+  return crypto.randomInt(min, max + 1);
+}

package/lib/tools/notes.js

@@ -0,0 +1,44 @@
+import { logger } from '../core/logger.js';
+
+export class NotesManager {
+  constructor(storage) {
+    this.storage = storage;
+    this._initDb();
+  }
+
+  _initDb() {
+    try {
+      this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS notes (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          agent_id TEXT NOT NULL,
+          contact_id TEXT NOT NULL,
+          title TEXT,
+          content TEXT NOT NULL,
+          tags TEXT DEFAULT '',
+          created_at TEXT DEFAULT (datetime('now')),
+          updated_at TEXT DEFAULT (datetime('now'))
+        )
+      `);
+    } catch {}
+  }
+
+  add(agentId, contactId, content, title = null) {
+    this.storage.db.prepare('INSERT INTO notes (agent_id, contact_id, title, content) VALUES (?, ?, ?, ?)').run(agentId, contactId, title, content);
+    return true;
+  }
+
+  list(agentId, contactId, limit = 10) {
+    return this.storage.db.prepare('SELECT * FROM notes WHERE agent_id = ? AND contact_id = ? ORDER BY created_at DESC LIMIT ?').all(agentId, contactId, limit);
+  }
+
+  search(agentId, contactId, query) {
+    return this.storage.db.prepare('SELECT * FROM notes WHERE agent_id = ? AND contact_id = ? AND (content LIKE ? OR title LIKE ?) ORDER BY created_at DESC LIMIT 10')
+      .all(agentId, contactId, `%${query}%`, `%${query}%`);
+  }
+
+  delete(agentId, id) {
+    this.storage.db.prepare('DELETE FROM notes WHERE id = ? AND agent_id = ?').run(id, agentId);
+    return true;
+  }
+}

package/lib/tools/router.js

@@ -59,6 +59,43 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    tools.push('', '### Save Note',
+      '---TOOL:note:content of the note---',
+      'Save a personal note for the user.',
+      '', '### List Notes',
+      '---TOOL:notes_list:all---',
+      'Show user\'s saved notes.',
+      '', '### Search Notes',
+      '---TOOL:notes_search:query---',
+      'Search through user\'s notes.',
+      '', '### Save Contact',
+      '---TOOL:contact_add:Name|phone|email---',
+      'Save a contact to the user\'s contact book.',
+      '', '### Find Contact',
+      '---TOOL:contact_find:name or number---',
+      'Search the user\'s contacts.',
+      '', '### Summarize Chat',
+      '---TOOL:summarize:conversation---',
+      'Summarize our conversation so far.',
+      '', '### Daily Briefing',
+      '---TOOL:briefing:now---',
+      'Generate a morning briefing (weather, tasks, news, reminders).',
+      '', '### Trivia Game',
+      '---TOOL:trivia:start---',
+      'Ask a trivia question.',
+      '', '### Riddle',
+      '---TOOL:riddle:start---',
+      'Tell a riddle.',
+      '', '### Coin Flip',
+      '---TOOL:coinflip:flip---',
+      'Flip a coin.',
+      '', '### Roll Dice',
+      '---TOOL:dice:6---',
+      'Roll a dice. Number is sides (default 6).',
+      '', '### Handoff to Human',
+      '---TOOL:handoff:reason---',
+      'Transfer the conversation to a human agent. Use when you cannot help further.');
+
     tools.push('', '### Run Command',
       '---TOOL:exec:ls -la---',
       'Execute a shell command. Output is returned. Sandboxed for safety.',
@@ -134,6 +171,12 @@ export class ToolRouter {
    * Process AI response — extract and execute tool calls
    * Returns: { toolUsed, toolResult, cleanResponse }
    */
+  setContext(engine, aiGateway, model) {
+    this._engine = engine;
+    this._aiGateway = aiGateway;
+    this._model = model;
+  }
+
   async processResponse(response, agentId) {
     const toolMatch = response.match(/---TOOL:(\w+):(.+?)---/);
     if (!toolMatch) return { toolUsed: false, toolResult: null, cleanResponse: response };
@@ -168,6 +211,84 @@ export class ToolRouter {
           }
           break;
         }
+        case 'note': {
+          const { NotesManager } = await import('./notes.js');
+          const nm = new NotesManager(this.storage);
+          nm.add(agentId, this._currentContactId || 'unknown', toolArg);
+          toolResult = 'Note saved! 📝';
+          break;
+        }
+        case 'notes_list': {
+          const { NotesManager } = await import('./notes.js');
+          const nm = new NotesManager(this.storage);
+          const notes = nm.list(agentId, this._currentContactId || 'unknown');
+          if (notes.length === 0) toolResult = 'No notes yet!';
+          else toolResult = notes.map((n, i) => (i+1) + '. ' + (n.title || n.content.slice(0, 50))).join('\n');
+          break;
+        }
+        case 'notes_search': {
+          const { NotesManager } = await import('./notes.js');
+          const nm = new NotesManager(this.storage);
+          const found = nm.search(agentId, this._currentContactId || 'unknown', toolArg);
+          if (found.length === 0) toolResult = 'No notes found for: ' + toolArg;
+          else toolResult = found.map(n => '• ' + n.content.slice(0, 100)).join('\n');
+          break;
+        }
+        case 'contact_add': {
+          const { ContactBook } = await import('./contacts.js');
+          const cb = new ContactBook(this.storage);
+          const parts = toolArg.split('|').map(p => p.trim());
+          cb.add(agentId, this._currentContactId || 'unknown', parts[0], parts[1], parts[2], parts[3]);
+          toolResult = 'Contact saved: ' + parts[0] + ' 📇';
+          break;
+        }
+        case 'contact_find': {
+          const { ContactBook } = await import('./contacts.js');
+          const cb = new ContactBook(this.storage);
+          const found = cb.find(agentId, this._currentContactId || 'unknown', toolArg);
+          if (found.length === 0) toolResult = 'No contacts found for: ' + toolArg;
+          else toolResult = found.map(c => '📇 ' + c.name + (c.phone ? ' — ' + c.phone : '') + (c.email ? ' — ' + c.email : '')).join('\n');
+          break;
+        }
+        case 'summarize': {
+          const { summarizeConversation } = await import('../features/conversation-summary.js');
+          toolResult = await summarizeConversation(this.storage, this._aiGateway, agentId, this._currentContactId, this._model);
+          break;
+        }
+        case 'briefing': {
+          const { generateBriefing } = await import('../features/daily-briefing.js');
+          toolResult = await generateBriefing(this._engine, agentId);
+          break;
+        }
+        case 'trivia': {
+          const { getTrivia } = await import('./games.js');
+          const t = getTrivia();
+          toolResult = '🎯 *Trivia!*\n\n' + t.q + '\n\n(Answer: ||' + t.a + '||)';
+          break;
+        }
+        case 'riddle': {
+          const { getRiddle } = await import('./games.js');
+          const r = getRiddle();
+          toolResult = '🧩 *Riddle!*\n\n' + r.q + '\n\n(Answer: ||' + r.a + '||)';
+          break;
+        }
+        case 'coinflip':
+        case 'coin': {
+          const { coinFlip } = await import('./games.js');
+          toolResult = coinFlip();
+          break;
+        }
+        case 'dice':
+        case 'roll': {
+          const { rollDice } = await import('./games.js');
+          const sides = parseInt(toolArg) || 6;
+          toolResult = '🎲 Rolled a ' + rollDice(sides) + '! (d' + sides + ')';
+          break;
+        }
+        case 'handoff': {
+          toolResult = '🤝 Transferring to a human agent. Reason: ' + toolArg;
+          break;
+        }
         case 'exec':
         case 'shell':
         case 'run': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {