squidclaw 0.9.0 → 1.0.0

package/lib/ai/prompt-builder.js

@@ -30,12 +30,48 @@ export class PromptBuilder {
     // 3. Long-term memories
     const memories = await this.storage.getMemories(agent.id);
     if (memories.length > 0) {
-      parts.push('\n## What You Remember\n');
-      for (const mem of memories.slice(0, 30)) {
-        parts.push(`- ${mem.key}: ${mem.value}`);
+      parts.push('\n## What You Remember');
+      parts.push('These are facts you have learned from conversations. Use them naturally — do not list them unless asked.');
+      parts.push('');
+      
+      // Group by type
+      const facts = memories.filter(m => m.type === 'fact' || m.type === 'auto');
+      const notes = memories.filter(m => m.type === 'noted');
+      
+      if (facts.length > 0) {
+        for (const mem of facts.slice(0, 40)) {
+          parts.push(`- ${mem.key}: ${mem.value}`);
+        }
+      }
+      if (notes.length > 0) {
+        parts.push('\n### User Notes (they asked you to remember):');
+        for (const mem of notes.slice(0, 20)) {
+          parts.push(`- ${mem.value}`);
+        }
       }
     }
 
+    // Platform-specific formatting
+    parts.push('\n## Message Format');
+    parts.push('- Keep messages SHORT (1-3 sentences per message)');
+    parts.push('- Use ---SPLIT--- to break long responses into multiple messages');
+    parts.push('- NO markdown tables — use bullet lists instead');
+    parts.push('- Use *bold* for emphasis, not headers');
+    parts.push('- When sharing multiple items, split into separate messages');
+    parts.push('- If user says "ok", "thanks", "👍" — do NOT reply with a full message. Use ---REACT:❤️--- only');
+    parts.push('- Act first, ask later. Do not say "would you like me to..." — just do it');
+    parts.push('- Never start with "Great question!" or "I would be happy to help!"');
+
+    // Memory instructions
+    parts.push('\n## Memory Instructions');
+    parts.push('When you learn something new about the user, save it using: ---MEMORY:key:value---');
+    parts.push('Examples:');
+    parts.push('  ---MEMORY:name:Tamer---');
+    parts.push('  ---MEMORY:favorite_food:Sushi---');
+    parts.push('  ---MEMORY:project:Building Squidclaw platform---');
+    parts.push('Save important facts automatically. Do not tell the user you are saving — just do it silently.');
+    parts.push('If the user says "remember X" — save it and confirm briefly.');
+
     // 4. Contact context
     const contact = await this.storage.getContact(agent.id, contactId);
     if (contact) {

package/lib/api/dashboard.js

@@ -0,0 +1,167 @@
+/**
+ * 🦑 Squidclaw Dashboard
+ * Minimal web UI for agent management
+ */
+
+export function addDashboardRoutes(app, engine) {
+  
+  // Dashboard HTML
+  app.get('/dashboard', (req, res) => {
+    res.send(DASHBOARD_HTML);
+  });
+
+  // API endpoints for dashboard
+  app.get('/api/dashboard/stats', async (req, res) => {
+    try {
+      const agents = engine.agentManager.listAll();
+      const stats = [];
+      
+      for (const agent of agents) {
+        const usage = await engine.storage.getUsage(agent.id);
+        const convos = engine.storage.db.prepare(
+          'SELECT COUNT(DISTINCT contact_id) as contacts FROM messages WHERE agent_id = ?'
+        ).get(agent.id);
+        
+        stats.push({
+          id: agent.id,
+          name: agent.name,
+          model: agent.model,
+          messages: usage?.messages || 0,
+          tokens: (usage?.input_tokens || 0) + (usage?.output_tokens || 0),
+          cost: (usage?.cost_usd || 0).toFixed(4),
+          contacts: convos?.contacts || 0,
+        });
+      }
+
+      const uptime = process.uptime();
+      const memUsage = process.memoryUsage();
+
+      res.json({
+        uptime: Math.floor(uptime),
+        memory: Math.round(memUsage.rss / 1024 / 1024),
+        agents: stats,
+        channels: {
+          whatsapp: Object.values(engine.whatsappManager?.getStatuses() || {}).some(s => s.connected),
+          telegram: !!engine.telegramManager?.bots?.size,
+        },
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/dashboard/conversations/:agentId', async (req, res) => {
+    try {
+      const contacts = engine.storage.db.prepare(
+        'SELECT contact_id, MAX(created_at) as last_msg, COUNT(*) as msg_count FROM messages WHERE agent_id = ? GROUP BY contact_id ORDER BY last_msg DESC LIMIT 50'
+      ).all(req.params.agentId);
+      res.json(contacts);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/dashboard/memories/:agentId', async (req, res) => {
+    try {
+      const memories = await engine.storage.getMemories(req.params.agentId);
+      res.json(memories);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+}
+
+const DASHBOARD_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>🦑 Squidclaw Dashboard</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0a0a0f; color: #e0e0e0; }
+    .header { background: linear-gradient(135deg, #1a1a2e, #16213e); padding: 20px 30px; border-bottom: 1px solid #333; display: flex; align-items: center; justify-content: space-between; }
+    .header h1 { font-size: 24px; } .header h1 span { color: #00d4ff; }
+    .status-bar { display: flex; gap: 20px; font-size: 14px; color: #888; }
+    .status-bar .online { color: #4caf50; }
+    .container { max-width: 1200px; margin: 30px auto; padding: 0 20px; }
+    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 20px; margin-bottom: 30px; }
+    .card { background: #1a1a2e; border: 1px solid #333; border-radius: 12px; padding: 20px; }
+    .card h3 { color: #00d4ff; margin-bottom: 15px; font-size: 16px; }
+    .stat { display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #222; }
+    .stat:last-child { border: none; }
+    .stat .label { color: #888; }
+    .stat .value { color: #fff; font-weight: 600; }
+    .agent-card { background: #1a1a2e; border: 1px solid #333; border-radius: 12px; padding: 20px; margin-bottom: 15px; }
+    .agent-card h3 { color: #00d4ff; margin-bottom: 10px; }
+    .agent-stats { display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; }
+    .agent-stat { text-align: center; }
+    .agent-stat .num { font-size: 24px; font-weight: 700; color: #fff; }
+    .agent-stat .lbl { font-size: 12px; color: #888; margin-top: 4px; }
+    .pill { display: inline-block; padding: 3px 10px; border-radius: 20px; font-size: 12px; }
+    .pill.on { background: #1b5e20; color: #4caf50; }
+    .pill.off { background: #4a1010; color: #e57373; }
+    .refresh-btn { background: #00d4ff; color: #000; border: none; padding: 8px 16px; border-radius: 8px; cursor: pointer; font-weight: 600; }
+    .refresh-btn:hover { background: #00b8d4; }
+    @media (max-width: 600px) { .agent-stats { grid-template-columns: repeat(2, 1fr); } }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>🦑 <span>Squidclaw</span> Dashboard</h1>
+    <div style="display:flex;gap:10px;align-items:center">
+      <div class="status-bar">
+        <span id="uptime">--</span>
+        <span id="memory">--</span>
+      </div>
+      <button class="refresh-btn" onclick="load()">Refresh</button>
+    </div>
+  </div>
+  <div class="container">
+    <div class="grid">
+      <div class="card">
+        <h3>📡 Channels</h3>
+        <div class="stat"><span class="label">WhatsApp</span><span id="wa" class="value">--</span></div>
+        <div class="stat"><span class="label">Telegram</span><span id="tg" class="value">--</span></div>
+      </div>
+      <div class="card">
+        <h3>📊 System</h3>
+        <div class="stat"><span class="label">Uptime</span><span id="uptimeVal" class="value">--</span></div>
+        <div class="stat"><span class="label">Memory</span><span id="memVal" class="value">--</span></div>
+        <div class="stat"><span class="label">Agents</span><span id="agentCount" class="value">--</span></div>
+      </div>
+    </div>
+    <h2 style="margin-bottom:15px;color:#00d4ff">🤖 Agents</h2>
+    <div id="agents"></div>
+  </div>
+  <script>
+    async function load() {
+      const res = await fetch('/api/dashboard/stats');
+      const data = await res.json();
+      const h = Math.floor(data.uptime/3600), m = Math.floor((data.uptime%3600)/60);
+      document.getElementById('uptimeVal').textContent = h+'h '+m+'m';
+      document.getElementById('memVal').textContent = data.memory+' MB';
+      document.getElementById('agentCount').textContent = data.agents.length;
+      document.getElementById('wa').innerHTML = data.channels.whatsapp ? '<span class="pill on">Connected</span>' : '<span class="pill off">Disconnected</span>';
+      document.getElementById('tg').innerHTML = data.channels.telegram ? '<span class="pill on">Connected</span>' : '<span class="pill off">Disconnected</span>';
+      
+      const agentsDiv = document.getElementById('agents');
+      agentsDiv.innerHTML = data.agents.map(a => \`
+        <div class="agent-card">
+          <h3>🤖 \${a.name || a.id}</h3>
+          <div style="margin-bottom:10px;color:#888;font-size:13px">Model: \${a.model} · ID: \${a.id.slice(0,8)}</div>
+          <div class="agent-stats">
+            <div class="agent-stat"><div class="num">\${a.messages}</div><div class="lbl">Messages</div></div>
+            <div class="agent-stat"><div class="num">\${a.contacts}</div><div class="lbl">Contacts</div></div>
+            <div class="agent-stat"><div class="num">\${fmtTokens(a.tokens)}</div><div class="lbl">Tokens</div></div>
+            <div class="agent-stat"><div class="num">$\${a.cost}</div><div class="lbl">Cost</div></div>
+          </div>
+        </div>
+      \`).join('');
+    }
+    function fmtTokens(n) { if(n>=1e6) return (n/1e6).toFixed(1)+'M'; if(n>=1e3) return (n/1e3).toFixed(1)+'K'; return n; }
+    load();
+    setInterval(load, 30000);
+  </script>
+</body>
+</html>`;

package/lib/channels/telegram/bot.js

@@ -166,6 +166,19 @@ export class TelegramManager {
     } catch {} // Reactions might not be supported in all chats
   }
 
+  async sendVoice(agentId, contactId, audioBuffer, metadata = {}) {
+    const chatId = metadata.chatId || contactId.replace('tg_', '');
+    const botInfo = this.bots.get(agentId);
+    if (!botInfo?.bot) return;
+
+    try {
+      const { InputFile } = await import('grammy');
+      await botInfo.bot.api.sendVoice(chatId, new InputFile(audioBuffer, 'voice.ogg'));
+    } catch (err) {
+      logger.error('telegram', 'Failed to send voice: ' + err.message);
+    }
+  }
+
   async sendPhoto(agentId, contactId, photoData, caption, metadata = {}) {
     const chatId = metadata.chatId || contactId;
     const token = metadata.token;

package/lib/cli/agent-cmd.js

@@ -1,182 +1,151 @@
+/**
+ * 🦑 squidclaw agent — manage agents
+ */
+
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
-import { loadConfig, getHome } from '../core/config.js';
-import { writeFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
 import crypto from 'crypto';
-import { createInterface } from 'readline';
+import { loadConfig, saveConfig, getHome } from '../core/config.js';
+import { mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
 
-export async function createAgent(opts) {
-  const home = getHome();
+export async function agentCommand(args) {
+  const sub = args[0];
+
+  switch (sub) {
+    case 'add': return addAgent();
+    case 'list': return listAgents();
+    case 'remove': return removeAgent(args[1]);
+    default:
+      console.log(chalk.cyan('🦑 Agent Commands:'));
+      console.log('  squidclaw agent add     — Create a new agent');
+      console.log('  squidclaw agent list    — List all agents');
+      console.log('  squidclaw agent remove  — Remove an agent');
+  }
+}
 
-  const name = opts.name || await p.text({ message: 'Agent name:', placeholder: 'Luna' });
+async function addAgent() {
+  p.intro(chalk.cyan('🦑 New Agent'));
+
+  const name = await p.text({ message: 'Agent name:', placeholder: 'Luna' });
   if (p.isCancel(name)) return;
 
-  const purpose = opts.soul || await p.text({ message: 'What does this agent do?', placeholder: 'Customer support for my restaurant' });
+  const purpose = await p.text({ message: 'What does this agent do?', placeholder: 'Customer support for my shop' });
   if (p.isCancel(purpose)) return;
 
-  const language = opts.language || await p.select({
+  const language = await p.select({
     message: 'Language:',
     options: [
-      { value: 'en', label: '🇬🇧 English' },
-      { value: 'ar', label: '🇸🇦 Arabic' },
-      { value: 'bilingual', label: '🌍 Bilingual' },
+      { value: 'bilingual', label: 'Bilingual (Arabic + English)' },
+      { value: 'en', label: 'English' },
+      { value: 'ar', label: 'Arabic' },
     ],
   });
-  if (p.isCancel(language)) return;
 
-  const tone = await p.select({
-    message: 'Tone:',
+  const personality = await p.select({
+    message: 'Personality:',
     options: [
-      { value: 30, label: '👔 Formal' },
-      { value: 50, label: '🤝 Professional but friendly' },
-      { value: 80, label: '😊 Casual and warm' },
+      { value: 'friendly', label: 'Friendly & Helpful' },
+      { value: 'professional', label: 'Professional & Formal' },
+      { value: 'casual', label: 'Casual & Fun' },
+      { value: 'expert', label: 'Expert & Technical' },
     ],
   });
-  if (p.isCancel(tone)) return;
 
-  const id = crypto.randomUUID().slice(0, 8);
+  const config = loadConfig();
+  const id = crypto.randomBytes(4).toString('hex');
+  const home = getHome();
   const agentDir = join(home, 'agents', id);
+
   mkdirSync(join(agentDir, 'memory'), { recursive: true });
 
-  const langDesc = language === 'ar' ? 'Arabic' : language === 'bilingual' ? 'Bilingual — match whatever language the person uses' : 'English';
-  const toneDesc = tone > 60 ? 'Casual and friendly' : tone > 30 ? 'Professional but warm' : 'Formal and polished';
+  // Create agent manifest
+  const manifest = {
+    id,
+    name,
+    purpose,
+    language,
+    personality,
+    model: config.ai?.defaultModel || 'claude-sonnet-4-20250514',
+    createdAt: new Date().toISOString(),
+  };
 
-  const soul = `# ${name}\n\n## Who I Am\nI'm ${name}. ${purpose}\n\n## How I Speak\n- Language: ${langDesc}\n- Tone: ${toneDesc}\n- Platform: WhatsApp — short messages, natural, human-like\n- I use emojis naturally but don't overdo it\n\n## What I Do\n${purpose}\n\n## What I Never Do\n- Say "As an AI" or "I'd be happy to help" or "Great question!"\n- Send walls of text\n- Make things up when I don't know\n`;
+  writeFileSync(join(agentDir, 'agent.json'), JSON.stringify(manifest, null, 2));
 
-  writeFileSync(join(agentDir, 'SOUL.md'), soul);
-  writeFileSync(join(agentDir, 'IDENTITY.md'), `# ${name}\n- Name: ${name}\n- Language: ${language}\n- Emoji: 🦑\n`);
-  writeFileSync(join(agentDir, 'MEMORY.md'), `# ${name}'s Memory\n\n_Learning..._\n`);
-  writeFileSync(join(agentDir, 'RULES.md'), `# Rules\n\n1. Be helpful, be human, be honest\n2. Keep messages short\n3. If unsure, say so\n`);
-  writeFileSync(join(agentDir, 'BEHAVIOR.md'), JSON.stringify({
-    splitMessages: true, maxChunkLength: 200, reactBeforeReply: true,
-    autoDetectLanguage: true, avoidPhrases: ["Is there anything else I can help with?", "I'd be happy to help!", "Great question!", "As an AI"],
-    handoff: { enabled: false }, heartbeat: '30m',
-  }, null, 2));
+  // Create SOUL.md
+  const langInst = language === 'bilingual' 
+    ? 'I speak Arabic and English fluently. I auto-detect what language the person uses and respond in the same language.'
+    : language === 'ar' ? 'I speak Arabic.' : 'I speak English.';
 
-  const config = loadConfig();
-  const manifest = { id, name, soul, language, tone, model: config.ai?.defaultModel, status: 'active', createdAt: new Date().toISOString() };
-  writeFileSync(join(agentDir, 'agent.json'), JSON.stringify(manifest, null, 2));
+  const soul = `# ${name}
+
+## Who I Am
+I am ${name}. ${purpose}.
+
+## How I Speak
+- ${langInst}
+- Short messages, natural, human-like
+- Personality: ${personality}
+- Emojis: natural but not overdone
+
+## My Skills
+- Search the web for current information
+- Read and summarize web pages
+- Remember facts about people I talk to
+- Set reminders
+
+## Never
+- Say "As an AI" or "Great question!" or "I would be happy to help!"
+- Send walls of text — keep it short
+- Make things up — search the web if unsure
+- Say I cannot access the internet — I can
+`;
+
+  writeFileSync(join(agentDir, 'SOUL.md'), soul);
+  writeFileSync(join(agentDir, 'MEMORY.md'), `# ${name} Memory\n`);
 
-  console.log(chalk.green(`\n✅ Agent "${name}" created (${id})`));
-  console.log(chalk.gray(`   Files: ${agentDir}`));
-  console.log(chalk.gray(`   Chat:  squidclaw agent chat ${id}\n`));
+  p.outro(chalk.green(`✅ Agent "${name}" created! (ID: ${id})`));
+  console.log(chalk.dim(`  Restart engine to load: squidclaw restart`));
 }
 
-export async function listAgents() {
+async function listAgents() {
   const home = getHome();
   const agentsDir = join(home, 'agents');
-  if (!existsSync(agentsDir)) return console.log(chalk.gray('No agents yet. Run: squidclaw agent create'));
-
-  const config = loadConfig();
-  const port = config.engine?.port || 9500;
-
-  // Try API first
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/api/agents`);
-    const agents = await res.json();
-    console.log(chalk.cyan(`\n  🦑 Agents (${agents.length})\n  ─────────`));
-    for (const a of agents) {
-      const wa = a.whatsappConnected ? chalk.green('📱 connected') : chalk.gray('📱 not linked');
-      console.log(`  ${a.name} (${a.id}) — ${a.model || 'default'} — ${wa}`);
-    }
-    console.log();
+  if (!existsSync(agentsDir)) {
+    console.log(chalk.yellow('No agents found.'));
     return;
-  } catch {}
+  }
+
+  const dirs = readdirSync(agentsDir, { withFileTypes: true }).filter(d => d.isDirectory());
+  console.log(chalk.cyan(`\n🦑 ${dirs.length} Agent(s):\n`));
 
-  // Fallback to filesystem
-  const dirs = readdirSync(agentsDir);
-  console.log(chalk.cyan(`\n  🦑 Agents (${dirs.length})\n  ─────────`));
   for (const dir of dirs) {
-    const manifestPath = join(agentsDir, dir, 'agent.json');
+    const manifestPath = join(agentsDir, dir.name, 'agent.json');
     if (existsSync(manifestPath)) {
-      const m = JSON.parse(readFileSync(manifestPath, 'utf8'));
-      console.log(`  ${m.name} (${m.id}) — ${m.model || 'default'} — ${m.status}`);
+      const manifest = JSON.parse((await import('fs')).readFileSync(manifestPath, 'utf8'));
+      console.log(`  🤖 ${manifest.name || dir.name}`);
+      console.log(chalk.dim(`     ID: ${manifest.id} · Model: ${manifest.model} · Lang: ${manifest.language || '?'}`));
     }
   }
-  console.log();
+  console.log('');
 }
 
-export async function editAgent(id) {
-  const home = getHome();
-  const agentDir = join(home, 'agents', id);
-  const soulPath = join(agentDir, 'SOUL.md');
-  if (!existsSync(soulPath)) return console.log(chalk.red(`Agent ${id} not found`));
-
-  console.log(chalk.cyan(`Edit files in: ${agentDir}`));
-  console.log(chalk.gray(`  SOUL.md     — personality`));
-  console.log(chalk.gray(`  RULES.md    — hard rules`));
-  console.log(chalk.gray(`  BEHAVIOR.md — behavior config`));
-  console.log(chalk.gray(`  MEMORY.md   — long-term memory\n`));
-}
-
-export async function deleteAgent(id) {
-  const confirm = await p.confirm({ message: `Delete agent ${id}? This cannot be undone.` });
-  if (!confirm || p.isCancel(confirm)) return;
-
-  const config = loadConfig();
-  const port = config.engine?.port || 9500;
-  try {
-    await fetch(`http://127.0.0.1:${port}/api/agents/${id}`, { method: 'DELETE' });
-    console.log(chalk.green(`✅ Agent ${id} deleted`));
-  } catch {
-    // Fallback: delete from filesystem
-    const { rmSync } = await import('fs');
-    const agentDir = join(getHome(), 'agents', id);
-    rmSync(agentDir, { recursive: true, force: true });
-    console.log(chalk.green(`✅ Agent ${id} deleted (filesystem)`));
+async function removeAgent(id) {
+  if (!id) {
+    console.log(chalk.red('Usage: squidclaw agent remove <agent-id>'));
+    return;
   }
-}
-
-export async function chatAgent(id) {
-  const config = loadConfig();
-  const port = config.engine?.port || 9500;
 
-  // Check if engine is running
-  try {
-    await fetch(`http://127.0.0.1:${port}/health`);
-  } catch {
-    console.log(chalk.red('Engine not running. Start with: squidclaw start'));
+  const home = getHome();
+  const agentDir = join(home, 'agents', id);
+  if (!existsSync(agentDir)) {
+    console.log(chalk.red('Agent not found: ' + id));
     return;
   }
 
-  // Get agent info
-  let agentName = id;
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${id}`);
-    const agent = await res.json();
-    agentName = agent.name || id;
-  } catch {}
-
-  console.log(chalk.cyan(`\n  🦑 Chat with ${agentName}`));
-  console.log(chalk.gray(`  Type your message. Ctrl+C to exit.\n`));
-
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  const ask = () => {
-    rl.question(chalk.green('You: '), async (input) => {
-      if (!input.trim()) return ask();
-
-      try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/agents/${id}/chat`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ message: input, contactId: 'terminal' }),
-        });
-        const data = await res.json();
-        for (const msg of data.messages || []) {
-          console.log(chalk.cyan(`${agentName}: `) + msg);
-        }
-        if (data.reaction) console.log(chalk.gray(`  (reacted: ${data.reaction})`));
-        if (data.usage) console.log(chalk.gray(`  [${data.usage.inputTokens}+${data.usage.outputTokens} tokens, $${data.usage.cost?.toFixed(4) || 0}]`));
-      } catch (err) {
-        console.log(chalk.red(`Error: ${err.message}`));
-      }
-      console.log();
-      ask();
-    });
-  };
+  const confirm = await p.confirm({ message: `Remove agent ${id}? This is permanent.` });
+  if (!confirm || p.isCancel(confirm)) return;
 
-  rl.on('close', () => { console.log(chalk.gray('\n  👋 Bye!\n')); process.exit(0); });
-  ask();
+  rmSync(agentDir, { recursive: true });
+  console.log(chalk.green(`✅ Agent ${id} removed.`));
 }

package/lib/cli/update-cmd.js

@@ -1,25 +1,53 @@
-import chalk from 'chalk';
+/**
+ * 🦑 squidclaw update — self-update to latest version
+ */
+
 import { execSync } from 'child_process';
+import chalk from 'chalk';
 
 export async function update() {
   console.log(chalk.cyan('🦑 Checking for updates...'));
+  
   try {
-    const current = execSync('npm view squidclaw version 2>/dev/null', { encoding: 'utf8' }).trim();
-    const { readFileSync } = await import('fs');
-    const { join, dirname } = await import('path');
-    const { fileURLToPath } = await import('url');
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+    // Get current version
+    const pkg = JSON.parse((await import('fs')).readFileSync(
+      new URL('../../package.json', import.meta.url), 'utf8'
+    ));
+    const current = pkg.version;
     
-    if (current && current !== pkg.version) {
-      console.log(`  Current: ${pkg.version} → Latest: ${current}`);
-      console.log(chalk.cyan('  Updating...'));
-      execSync('npm i -g squidclaw@latest', { stdio: 'inherit' });
-      console.log(chalk.green('  ✅ Updated!'));
-    } else {
-      console.log(chalk.green(`  ✅ Already on latest (${pkg.version})`));
+    // Get latest from npm
+    let latest;
+    try {
+      latest = execSync('npm view squidclaw version', { encoding: 'utf8' }).trim();
+    } catch {
+      latest = current;
     }
-  } catch {
-    console.log(chalk.yellow('  Could not check for updates. Try: npm i -g squidclaw@latest'));
+    
+    console.log(`  Current: ${chalk.yellow(current)}`);
+    console.log(`  Latest:  ${chalk.green(latest)}`);
+    
+    if (current === latest) {
+      console.log(chalk.green('\n✅ Already up to date!'));
+      return;
+    }
+    
+    console.log(chalk.cyan('\n📦 Updating...'));
+    execSync('npm i -g squidclaw@latest', { stdio: 'inherit' });
+    
+    // Check if engine is running
+    try {
+      const res = await fetch('http://127.0.0.1:9500/health');
+      if (res.ok) {
+        console.log(chalk.cyan('\n🔄 Restarting engine...'));
+        execSync('pkill -f "squidclaw start"', { stdio: 'ignore' });
+        await new Promise(r => setTimeout(r, 2000));
+        execSync('nohup squidclaw start > /tmp/squidclaw.log 2>&1 &', { stdio: 'ignore' });
+        console.log(chalk.green('✅ Engine restarted!'));
+      }
+    } catch {}
+    
+    console.log(chalk.green(`\n✅ Updated to v${latest}!`));
+  } catch (err) {
+    console.error(chalk.red('❌ Update failed:'), err.message);
   }
 }

package/lib/core/agent-tools-mixin.js

@@ -29,6 +29,11 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
     agent.promptBuilder.build = async function(agentObj, cId, msg) {
       let prompt = await origBuild(agentObj, cId, msg);
       
+      // Add link context (auto-read URLs)
+      if (metadata._linkContext) {
+        prompt += '\n\n## Content From Links Shared\nThe user shared links. Here is the content:\n\n' + metadata._linkContext;
+      }
+
       // Add knowledge context
       if (metadata._knowledgeContext) {
         prompt += '\n\n## Relevant Knowledge\nUse this information to answer:\n\n' + metadata._knowledgeContext;

package/lib/engine.js

@@ -107,6 +107,31 @@ export class SquidclawEngine {
             return;
           }
 
+          // 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;
+          }
+
           // Handle /help command
           if (message.trim() === '/help') {
             const helpText = [
@@ -115,6 +140,7 @@ export class SquidclawEngine {
               '/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! 🦑',
@@ -200,6 +226,139 @@ export class SquidclawEngine {
             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);
+            }
+          }
+
+          // 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 {}
+          }
+
+          // 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 {}
+          }
+
+          // Auto-extract facts from user message
+          if (this.autoMemory) {
+            try { await this.autoMemory.extract(agentId, contactId, message); } catch {}
+          }
+
           // Check if user is asking for a skill we don't have
           const skillRequest = detectSkillRequest(message);
           if (skillRequest) {
@@ -214,10 +373,10 @@ export class SquidclawEngine {
           }
 
           // Show typing indicator while processing
-          const chatId = metadata.chatId || contactId;
-          const botInfo = this.telegramManager?.bots?.values()?.next()?.value;
+          const chatId = metadata.chatId || contactId.replace('tg_', '');
+          const botInfo = this.telegramManager?.bots?.get(agentId);
           let typingInterval;
-          if (botInfo) {
+          if (botInfo?.bot) {
             const sendTyping = () => { try { botInfo.bot.api.sendChatAction(chatId, 'typing').catch(() => {}); } catch {} };
             sendTyping();
             typingInterval = setInterval(sendTyping, 4000);
@@ -256,6 +415,19 @@ export class SquidclawEngine {
             // 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);
             }
@@ -305,10 +477,11 @@ export class SquidclawEngine {
     this.heartbeat.start();
     console.log(`  💓 Heartbeat: active`);
 
-    // 7. API Server
+    // 7. API Server + Dashboard
     const app = createAPIServer(this);
-    this.server = app.listen(this.port, this.config.engine?.bind || '127.0.0.1', () => {
-      console.log(`  🌐 API: http://${this.config.engine?.bind || '127.0.0.1'}:${this.port}`);
+    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(`  ──────────────────────────`);
       console.log(`  ✅ Engine running!\n`);
     });

package/lib/features/auto-links.js

@@ -0,0 +1,36 @@
+/**
+ * 🦑 Auto-Link Reader
+ * Detects URLs in messages and fetches their content for context
+ */
+
+import { logger } from '../core/logger.js';
+
+const URL_REGEX = /https?:\/\/[^\s<>"')\]]+/gi;
+
+export async function extractAndReadLinks(message, browser) {
+  const urls = message.match(URL_REGEX);
+  if (!urls || urls.length === 0) return null;
+
+  const results = [];
+  for (const url of urls.slice(0, 3)) { // Max 3 links
+    try {
+      const page = await browser.readPage(url, 2000);
+      if (page && page.content) {
+        results.push({
+          url,
+          title: page.title || url,
+          content: page.content.slice(0, 1500),
+        });
+        logger.info('auto-links', `Read: ${page.title || url}`);
+      }
+    } catch (err) {
+      logger.warn('auto-links', `Failed to read ${url}: ${err.message}`);
+    }
+  }
+
+  if (results.length === 0) return null;
+
+  return results.map(r => 
+    `[Link: ${r.title}]\nURL: ${r.url}\nContent:\n${r.content}`
+  ).join('\n\n---\n\n');
+}

package/lib/features/auto-memory.js

@@ -0,0 +1,107 @@
+/**
+ * 🦑 Auto Memory — Extracts facts from conversations automatically
+ * No AI tags needed — scans messages for personal info, preferences, decisions
+ */
+
+import { logger } from '../core/logger.js';
+
+const FACT_PATTERNS = [
+  // Names
+  { regex: /(?:my name is|call me|i'?m|ana|اسمي|اسم)\s+([A-Z\u0600-\u06FF][a-z\u0600-\u06FF]+)/i, key: 'name', extract: 1 },
+  
+  // Location
+  { regex: /(?:i live in|i'?m from|i'?m in|based in|located in|ساكن في|من)\s+([A-Z\u0600-\u06FF][\w\u0600-\u06FF\s]{2,20})/i, key: 'location', extract: 1 },
+  
+  // Job
+  { regex: /(?:i work (?:as|at|in|for)|my job is|i'?m a|i'?m an|اشتغل|شغلي)\s+(.{3,40}?)(?:\.|,|!|\?|$)/i, key: 'job', extract: 1 },
+  
+  // Age
+  { regex: /(?:i'?m|i am|عمري)\s+(\d{1,3})\s*(?:years? old|سنة|سنه)?/i, key: 'age', extract: 1 },
+  
+  // Family
+  { regex: /(?:my (?:wife|husband|son|daughter|brother|sister|mom|dad|father|mother)(?:'s name)? is)\s+(\w+)/i, key: (m) => m[0].match(/wife|husband|son|daughter|brother|sister|mom|dad|father|mother/i)[0], extract: 1 },
+  
+  // Favorites
+  { regex: /(?:my fav(?:orite|ourite)?\s+(\w+)\s+is)\s+(.+?)(?:\.|,|!|$)/i, key: (m) => 'favorite_' + m[1], extract: 2 },
+  { regex: /(?:i (?:love|like|prefer|enjoy))\s+(.{3,30}?)(?:\.|,|!|\?|$)/i, key: 'likes', extract: 1, append: true },
+  { regex: /(?:i (?:hate|dislike|don'?t like))\s+(.{3,30}?)(?:\.|,|!|\?|$)/i, key: 'dislikes', extract: 1, append: true },
+  
+  // Timezone
+  { regex: /(?:my time(?:zone)? is|i'?m in)\s+(UTC[+-]\d+|GMT[+-]\d+|[A-Z]{2,4}\/[A-Za-z_]+)/i, key: 'timezone', extract: 1 },
+  
+  // Birthday
+  { regex: /(?:my birthday is|born on|ميلادي)\s+(.{5,20})/i, key: 'birthday', extract: 1 },
+
+  // Language
+  { regex: /(?:i speak|my language is|لغتي)\s+(\w+)/i, key: 'language', extract: 1 },
+  
+  // Pet
+  { regex: /(?:my (?:cat|dog|pet)(?:'s name)? is)\s+(\w+)/i, key: (m) => m[0].match(/cat|dog|pet/i)[0] + '_name', extract: 1 },
+];
+
+// Extract per-contact facts
+const CONTACT_PATTERNS = [
+  { regex: /(?:remember|don'?t forget|note|تذكر|لا تنسى)\s+(?:that\s+)?(.{5,100})/i, key: 'noted', extract: 1 },
+];
+
+export class AutoMemory {
+  constructor(storage) {
+    this.storage = storage;
+  }
+
+  /**
+   * Scan a user message for facts and auto-save them
+   */
+  async extract(agentId, contactId, message) {
+    const extracted = [];
+
+    for (const pattern of FACT_PATTERNS) {
+      const match = message.match(pattern.regex);
+      if (!match) continue;
+
+      const key = typeof pattern.key === 'function' ? pattern.key(match) : pattern.key;
+      const value = match[pattern.extract].trim();
+
+      if (value.length < 2 || value.length > 100) continue;
+
+      if (pattern.append) {
+        // Append to existing
+        const existing = await this._getMemory(agentId, key);
+        if (existing && existing.includes(value)) continue;
+        const newValue = existing ? existing + ', ' + value : value;
+        await this.storage.saveMemory(agentId, key, newValue, 'auto');
+      } else {
+        await this.storage.saveMemory(agentId, key, value, 'auto');
+      }
+
+      extracted.push({ key, value });
+      logger.info('auto-memory', `Extracted: ${key} = ${value}`);
+    }
+
+    // Check "remember this" patterns
+    for (const pattern of CONTACT_PATTERNS) {
+      const match = message.match(pattern.regex);
+      if (!match) continue;
+      const value = match[pattern.extract].trim();
+      if (value.length < 3) continue;
+      
+      const key = 'user_note_' + Date.now().toString(36);
+      await this.storage.saveMemory(agentId, key, value, 'noted');
+      extracted.push({ key, value });
+      logger.info('auto-memory', `User note: ${value}`);
+    }
+
+    return extracted;
+  }
+
+  async _getMemory(agentId, key) {
+    try {
+      const row = this.storage.db.prepare(
+        'SELECT value FROM memories WHERE agent_id = ? AND key = ?'
+      ).get(agentId, key);
+      return row?.value;
+    } catch {
+      return null;
+    }
+  }
+}

package/lib/features/doc-ingest.js

@@ -0,0 +1,103 @@
+/**
+ * 🦑 Document Ingestion
+ * Process PDFs, text files, docs sent via chat into knowledge base
+ */
+
+import { logger } from '../core/logger.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class DocIngester {
+  constructor(storage, knowledgeBase, home) {
+    this.storage = storage;
+    this.kb = knowledgeBase;
+    this.home = home;
+  }
+
+  async ingest(agentId, buffer, filename, mimeType) {
+    logger.info('doc-ingest', `Processing ${filename} (${mimeType})`);
+
+    let text = '';
+
+    if (mimeType === 'application/pdf') {
+      text = await this._extractPdf(buffer);
+    } else if (mimeType?.includes('text') || filename.endsWith('.txt') || filename.endsWith('.md') || filename.endsWith('.csv')) {
+      text = buffer.toString('utf8');
+    } else if (filename.endsWith('.json')) {
+      text = buffer.toString('utf8');
+    } else {
+      // Try as text
+      text = buffer.toString('utf8');
+      if (text.includes('\ufffd') || /[\x00-\x08\x0e-\x1f]/.test(text.slice(0, 100))) {
+        throw new Error('Unsupported file format: ' + mimeType);
+      }
+    }
+
+    if (!text || text.trim().length < 10) {
+      throw new Error('Could not extract text from file');
+    }
+
+    // Save raw file
+    const docsDir = join(this.home, 'agents', agentId, 'docs');
+    mkdirSync(docsDir, { recursive: true });
+    writeFileSync(join(docsDir, filename), buffer);
+
+    // Chunk and save to knowledge base
+    const chunks = this._chunk(text, 500);
+    const docId = 'doc_' + Date.now().toString(36);
+
+    await this.storage.saveDocument(agentId, {
+      id: docId,
+      title: filename,
+      content: text.slice(0, 500),
+      type: mimeType,
+      chunk_count: chunks.length,
+    });
+
+    for (let i = 0; i < chunks.length; i++) {
+      await this.storage.saveKnowledgeChunk(agentId, {
+        document_id: docId,
+        content: chunks[i],
+        chunk_index: i,
+      });
+    }
+
+    logger.info('doc-ingest', `Saved ${chunks.length} chunks from ${filename}`);
+    return { docId, chunks: chunks.length, chars: text.length };
+  }
+
+  async _extractPdf(buffer) {
+    // Try pdf-parse if available
+    try {
+      const pdfParse = (await import('pdf-parse')).default;
+      const data = await pdfParse(buffer);
+      return data.text;
+    } catch {
+      // Fallback: basic text extraction
+      const text = buffer.toString('utf8');
+      const readable = text.replace(/[^\x20-\x7E\n\r\t\u0600-\u06FF]/g, ' ')
+                          .replace(/\s{3,}/g, '\n')
+                          .trim();
+      if (readable.length > 50) return readable;
+      throw new Error('PDF parsing requires pdf-parse package. Run: npm i pdf-parse');
+    }
+  }
+
+  _chunk(text, maxWords) {
+    const paragraphs = text.split(/\n\s*\n/);
+    const chunks = [];
+    let current = '';
+
+    for (const para of paragraphs) {
+      const words = (current + '\n\n' + para).split(/\s+/).length;
+      if (words > maxWords && current) {
+        chunks.push(current.trim());
+        current = para;
+      } else {
+        current = current ? current + '\n\n' + para : para;
+      }
+    }
+    if (current.trim()) chunks.push(current.trim());
+    return chunks;
+  }
+}

package/lib/features/usage-alerts.js

@@ -0,0 +1,49 @@
+/**
+ * 🦑 Usage Alerts
+ * Track spending and alert when thresholds are hit
+ */
+
+import { logger } from '../core/logger.js';
+
+export class UsageAlerts {
+  constructor(storage) {
+    this.storage = storage;
+    this.thresholds = [1, 5, 10, 25, 50, 100]; // USD
+    this.alerted = new Set(); // track which thresholds already alerted
+  }
+
+  async check(agentId) {
+    try {
+      const usage = this.storage.db.prepare(
+        "SELECT SUM(cost_usd) as total FROM usage WHERE agent_id = ? AND created_at >= date('now', '-1 day')"
+      ).get(agentId);
+
+      const total = usage?.total || 0;
+
+      for (const threshold of this.thresholds) {
+        const key = `${agentId}_${threshold}`;
+        if (total >= threshold && !this.alerted.has(key)) {
+          this.alerted.add(key);
+          logger.warn('usage', `Agent ${agentId} hit $${threshold} in 24h (total: $${total.toFixed(2)})`);
+          return { alert: true, threshold, total: total.toFixed(2) };
+        }
+      }
+    } catch {}
+    return { alert: false };
+  }
+
+  async getSummary(agentId) {
+    const today = this.storage.db.prepare(
+      "SELECT SUM(cost_usd) as cost, COUNT(*) as calls, SUM(input_tokens + output_tokens) as tokens FROM usage WHERE agent_id = ? AND created_at >= date('now')"
+    ).get(agentId) || {};
+
+    const month = this.storage.db.prepare(
+      "SELECT SUM(cost_usd) as cost, COUNT(*) as calls, SUM(input_tokens + output_tokens) as tokens FROM usage WHERE agent_id = ? AND created_at >= date('now', '-30 days')"
+    ).get(agentId) || {};
+
+    return {
+      today: { cost: (today.cost || 0).toFixed(4), calls: today.calls || 0, tokens: today.tokens || 0 },
+      month: { cost: (month.cost || 0).toFixed(4), calls: month.calls || 0, tokens: month.tokens || 0 },
+    };
+  }
+}

package/lib/features/voice-reply.js

@@ -0,0 +1,55 @@
+/**
+ * 🦑 Voice Replies
+ * Convert text to speech and send as voice note
+ */
+
+import { logger } from '../core/logger.js';
+
+export class VoiceReply {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async generate(text, options = {}) {
+    const providers = this.config.ai?.providers || {};
+
+    // OpenAI TTS
+    if (providers.openai?.key) {
+      return this._openaiTTS(text, providers.openai.key, options);
+    }
+
+    // Google TTS (free via Translate trick)
+    return this._googleFreeTTS(text, options);
+  }
+
+  async _openaiTTS(text, apiKey, options) {
+    const voice = options.voice || 'nova';
+    const res = await fetch('https://api.openai.com/v1/audio/speech', {
+      method: 'POST',
+      headers: { 'Authorization': 'Bearer ' + apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'tts-1',
+        input: text.slice(0, 4096),
+        voice,
+        response_format: 'opus',
+      }),
+    });
+
+    if (!res.ok) throw new Error('OpenAI TTS failed: ' + res.statusText);
+    return Buffer.from(await res.arrayBuffer());
+  }
+
+  async _googleFreeTTS(text, options) {
+    // Google Translate TTS — free, no API key needed
+    const lang = options.language === 'ar' ? 'ar' : 'en';
+    const encoded = encodeURIComponent(text.slice(0, 200));
+    const url = `https://translate.google.com/translate_tts?ie=UTF-8&q=${encoded}&tl=${lang}&client=tw-ob`;
+    
+    const res = await fetch(url, {
+      headers: { 'User-Agent': 'Mozilla/5.0' },
+    });
+    
+    if (!res.ok) throw new Error('Google TTS failed');
+    return Buffer.from(await res.arrayBuffer());
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "squidclaw",
-  "version": "0.9.0",
-  "description": "\ud83e\udd91 AI agent platform \u2014 human-like agents for WhatsApp, Telegram & more",
+  "version": "1.0.0",
+  "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {
     "squidclaw": "./bin/squidclaw.js"
@@ -55,4 +55,4 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   }
-}
+}