squidclaw 0.1.0

package/lib/cli/agent-cmd.js

@@ -0,0 +1,182 @@
+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';
+
+export async function createAgent(opts) {
+  const home = getHome();
+
+  const name = opts.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' });
+  if (p.isCancel(purpose)) return;
+
+  const language = opts.language || await p.select({
+    message: 'Language:',
+    options: [
+      { value: 'en', label: '🇬🇧 English' },
+      { value: 'ar', label: '🇸🇦 Arabic' },
+      { value: 'bilingual', label: '🌍 Bilingual' },
+    ],
+  });
+  if (p.isCancel(language)) return;
+
+  const tone = await p.select({
+    message: 'Tone:',
+    options: [
+      { value: 30, label: '👔 Formal' },
+      { value: 50, label: '🤝 Professional but friendly' },
+      { value: 80, label: '😊 Casual and warm' },
+    ],
+  });
+  if (p.isCancel(tone)) return;
+
+  const id = crypto.randomUUID().slice(0, 8);
+  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';
+
+  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, '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));
+
+  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));
+
+  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`));
+}
+
+export 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();
+    return;
+  } catch {}
+
+  // 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');
+    if (existsSync(manifestPath)) {
+      const m = JSON.parse(readFileSync(manifestPath, 'utf8'));
+      console.log(`  ${m.name} (${m.id}) — ${m.model || 'default'} — ${m.status}`);
+    }
+  }
+  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)`));
+  }
+}
+
+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'));
+    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();
+    });
+  };
+
+  rl.on('close', () => { console.log(chalk.gray('\n  👋 Bye!\n')); process.exit(0); });
+  ask();
+}

package/lib/cli/brain-cmd.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig, MODEL_MAP, MODEL_PRICING } from '../core/config.js';
+
+export async function listBrains() {
+  const config = loadConfig();
+  console.log(chalk.cyan('\n  🧠 Available Models\n  ──────────────────'));
+
+  const groups = [
+    { name: 'Anthropic', provider: 'anthropic', models: ['claude-opus-4', 'claude-sonnet-4', 'claude-haiku-3.5'] },
+    { name: 'OpenAI', provider: 'openai', models: ['gpt-4o', 'gpt-4o-mini', 'o3', 'o4-mini'] },
+    { name: 'Google', provider: 'google', models: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash'] },
+    { name: 'Groq (free)', provider: 'groq', models: ['groq/llama-4-scout', 'groq/llama-4-maverick', 'groq/llama-3.3-70b'] },
+    { name: 'Together (free)', provider: 'together', models: ['together/llama-4-scout', 'together/llama-4-maverick'] },
+    { name: 'Cerebras (free)', provider: 'cerebras', models: ['cerebras/llama-3.3-70b'] },
+    { name: 'Mistral', provider: 'mistral', models: ['mistral-large', 'mistral-medium', 'mistral-small'] },
+    { name: 'Local', provider: 'ollama', models: ['ollama/local', 'lmstudio/local'] },
+  ];
+
+  for (const group of groups) {
+    const hasKey = config.ai?.providers?.[group.provider]?.key;
+    const keyStatus = hasKey ? chalk.green('✅') : chalk.gray('no key');
+    console.log(`\n  ${group.name} (${keyStatus})`);
+    for (const model of group.models) {
+      const pricing = MODEL_PRICING[model];
+      const priceStr = pricing ? (pricing.input === 0 ? chalk.green('free') : chalk.gray(`$${pricing.input}/$${pricing.output} per 1M`)) : '';
+      const current = model === config.ai?.defaultModel ? chalk.green(' ← current') : '';
+      console.log(`  ├── ${model} ${priceStr}${current}`);
+    }
+  }
+  console.log();
+}
+
+export async function setBrain(model, opts) {
+  const config = loadConfig();
+  config.ai.defaultModel = model;
+  saveConfig(config);
+  console.log(chalk.green(`✅ Default model set to ${model}`));
+}
+
+export async function showBrain() {
+  const config = loadConfig();
+  console.log(chalk.cyan('\n  🧠 Current Brain'));
+  console.log(`  Provider: ${config.ai?.defaultProvider || 'not set'}`);
+  console.log(`  Model:    ${config.ai?.defaultModel || 'not set'}`);
+  if (config.ai?.fallbackChain?.length) {
+    console.log(`  Fallback: ${config.ai.fallbackChain.join(' → ')}`);
+  }
+  console.log();
+}

package/lib/cli/broadcast-cmd.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function sendBroadcast(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+
+  // Get contacts for the agent
+  try {
+    const contactsRes = await fetch(`http://127.0.0.1:${port}/api/agents/${opts.agent}/contacts`);
+    const contacts = await contactsRes.json();
+
+    if (contacts.length === 0) {
+      return console.log(chalk.yellow('No contacts to broadcast to'));
+    }
+
+    const contactIds = contacts.map(c => c.contact_id);
+    console.log(chalk.cyan(`Broadcasting to ${contactIds.length} contacts...`));
+
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${opts.agent}/broadcast`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ message: opts.message, contactIds }),
+    });
+    const result = await res.json();
+    console.log(chalk.green(`✅ Sent: ${result.sent} | Failed: ${result.failed}`));
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/cli/channels-cmd.js

@@ -0,0 +1,157 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadConfig, getHome } from '../core/config.js';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export async function loginChannel(channel, opts) {
+  if (channel !== 'whatsapp') {
+    console.log(chalk.yellow(`${channel} support coming soon 🦑`));
+    return;
+  }
+
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const home = getHome();
+
+  // Find agent
+  let agentId = opts.agent;
+  if (!agentId) {
+    const agentsDir = join(home, 'agents');
+    if (existsSync(agentsDir)) {
+      const dirs = readdirSync(agentsDir).filter(d => existsSync(join(agentsDir, d, 'agent.json')));
+      if (dirs.length === 1) {
+        agentId = dirs[0];
+      } else if (dirs.length > 1) {
+        const choices = dirs.map(d => {
+          const m = JSON.parse(readFileSync(join(agentsDir, d, 'agent.json'), 'utf8'));
+          return { value: d, label: `${m.name} (${d})` };
+        });
+        agentId = await p.select({ message: 'Which agent?', options: choices });
+        if (p.isCancel(agentId)) return;
+      }
+    }
+    if (!agentId) return console.log(chalk.red('No agents found. Run: squidclaw agent create'));
+  }
+
+  // Choose method
+  const method = opts.method || await p.select({
+    message: 'Login method:',
+    options: [
+      { value: 'pairing', label: '📱 Pairing Code (enter phone number)' },
+      { value: 'qr', label: '📷 QR Code (scan with camera)' },
+    ],
+  });
+  if (p.isCancel(method)) return;
+
+  if (method === 'pairing') {
+    const phone = await p.text({
+      message: '📱 Phone number (with country code):',
+      placeholder: '+966 5XX XXX XXXX',
+      validate: v => v.replace(/[^0-9+]/g, '').length < 8 ? 'Enter a valid number' : undefined,
+    });
+    if (p.isCancel(phone)) return;
+
+    const spinner = p.spinner();
+    spinner.start('Requesting pairing code...');
+
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/whatsapp/pair`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ phone: phone.replace(/[^0-9+]/g, '') }),
+      });
+      const data = await res.json();
+
+      if (data.pairingCode) {
+        spinner.stop('Pairing code ready!');
+        console.log(chalk.cyan(`\n  📱 Pairing Code: ${chalk.bold.white(data.pairingCode)}`));
+        console.log(chalk.gray(`\n  Open WhatsApp → Settings → Linked Devices → Link with phone number`));
+        console.log(chalk.gray(`  Enter the code above\n`));
+
+        // Poll for connection
+        const pollSpinner = p.spinner();
+        pollSpinner.start('Waiting for you to enter the code...');
+        for (let i = 0; i < 60; i++) {
+          await new Promise(r => setTimeout(r, 2000));
+          try {
+            const statusRes = await fetch(`http://127.0.0.1:${port}/api/whatsapp/status`);
+            const statuses = await statusRes.json();
+            if (statuses[agentId]?.connected) {
+              pollSpinner.stop(chalk.green('✅ WhatsApp connected!'));
+              return;
+            }
+          } catch {}
+        }
+        pollSpinner.stop(chalk.yellow('Timed out — check status with: squidclaw channels status'));
+      } else {
+        spinner.stop(chalk.red(`Failed: ${data.error || 'Unknown error'}`));
+      }
+    } catch (err) {
+      spinner.stop(chalk.red(`Error: ${err.message}`));
+      console.log(chalk.gray('Make sure the engine is running: squidclaw start'));
+    }
+  } else {
+    // QR code method
+    const spinner = p.spinner();
+    spinner.start('Generating QR code...');
+
+    try {
+      await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/whatsapp/start`, { method: 'POST' });
+      spinner.stop('Check terminal for QR code — scan with WhatsApp → Linked Devices');
+      console.log(chalk.gray('Waiting for scan...'));
+
+      // Poll for connection
+      for (let i = 0; i < 60; i++) {
+        await new Promise(r => setTimeout(r, 2000));
+        try {
+          const statusRes = await fetch(`http://127.0.0.1:${port}/api/whatsapp/status`);
+          const statuses = await statusRes.json();
+          if (statuses[agentId]?.connected) {
+            console.log(chalk.green('\n✅ WhatsApp connected!\n'));
+            return;
+          }
+        } catch {}
+      }
+    } catch (err) {
+      spinner.stop(chalk.red(`Error: ${err.message}`));
+    }
+  }
+}
+
+export async function channelStatus() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/whatsapp/status`);
+    const statuses = await res.json();
+
+    const agentsRes = await fetch(`http://127.0.0.1:${port}/api/agents`);
+    const agents = await agentsRes.json();
+
+    console.log(chalk.cyan('\n  📡 Channel Status\n  ────────────────'));
+    for (const agent of agents) {
+      const wa = statuses[agent.id];
+      const waStatus = wa?.connected ? chalk.green('● connected') : chalk.red('● disconnected');
+      console.log(`  ${agent.name}: WhatsApp ${waStatus}`);
+    }
+    console.log();
+  } catch {
+    console.log(chalk.red('Engine not running. Start with: squidclaw start'));
+  }
+}
+
+export async function logoutChannel(channel, opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/whatsapp/stop`, { method: 'POST' });
+    console.log(chalk.green('✅ WhatsApp disconnected'));
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}

package/lib/cli/config-cmd.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { loadConfig, setConfigValue } from '../core/config.js';
+
+export async function getConfig(key) {
+  const config = loadConfig();
+  if (key) {
+    const val = key.split('.').reduce((obj, k) => obj?.[k], config);
+    console.log(typeof val === 'object' ? JSON.stringify(val, null, 2) : val);
+  } else {
+    console.log(JSON.stringify(config, null, 2));
+  }
+}
+
+export async function setConfig(key, value) {
+  setConfigValue(key, value);
+  console.log(chalk.green(`✅ ${key} = ${value}`));
+}
+
+export async function editConfig() {
+  const { getHome } = await import('../core/config.js');
+  const { join } = await import('path');
+  const configPath = join(getHome(), 'config.json');
+  const editor = process.env.EDITOR || 'nano';
+  const { execSync } = await import('child_process');
+  execSync(`${editor} ${configPath}`, { stdio: 'inherit' });
+}

package/lib/cli/conversations-cmd.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function listConversations(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/contacts`);
+    const contacts = await res.json();
+    console.log(chalk.cyan(`\n  💬 Conversations (${contacts.length})\n  ──────────────`));
+    for (const c of contacts.slice(0, parseInt(opts.limit) || 20)) {
+      console.log(`  ${c.name || c.contact_id} — ${c.message_count} msgs — last: ${c.last_seen}`);
+    }
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function searchConversations(query, opts) {
+  console.log(chalk.yellow('Search coming soon 🦑'));
+}
+
+export async function exportConversations(opts) {
+  console.log(chalk.yellow('Export coming soon 🦑'));
+}

package/lib/cli/engine-cmd.js

@@ -0,0 +1,115 @@
+/**
+ * 🦑 Engine CLI Commands
+ * start, stop, restart, status
+ */
+
+import chalk from 'chalk';
+import { loadConfig, getHome } from '../core/config.js';
+import { SquidclawEngine } from '../engine.js';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+export async function start(opts) {
+  const engine = new SquidclawEngine({ port: parseInt(opts.port) || 9500 });
+  
+  // Load agents from filesystem into DB on first start
+  await engine.start();
+  
+  // Auto-register agents from filesystem
+  const agentsDir = join(getHome(), 'agents');
+  if (existsSync(agentsDir)) {
+    for (const dir of readdirSync(agentsDir)) {
+      const manifestPath = join(agentsDir, dir, 'agent.json');
+      if (existsSync(manifestPath)) {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const existing = await engine.storage.getAgent(manifest.id);
+        if (!existing) {
+          // Read soul from file
+          const soulPath = join(agentsDir, dir, 'SOUL.md');
+          if (existsSync(soulPath)) {
+            manifest.soul = readFileSync(soulPath, 'utf8');
+          }
+          const behaviorPath = join(agentsDir, dir, 'BEHAVIOR.md');
+          if (existsSync(behaviorPath)) {
+            try { manifest.behavior = JSON.parse(readFileSync(behaviorPath, 'utf8')); } catch {}
+          }
+          await engine.agentManager.create(manifest);
+          console.log(`  📦 Registered agent "${manifest.name}" from filesystem`);
+          
+          // Start WhatsApp if configured
+          if (manifest.whatsappNumber) {
+            try {
+              await engine.whatsappManager.startSession(manifest.id);
+            } catch {}
+          }
+        }
+      }
+    }
+  }
+}
+
+export async function stop() {
+  console.log(chalk.yellow('🦑 Stopping Squidclaw...'));
+  try {
+    const config = loadConfig();
+    const port = config.engine?.port || 9500;
+    await fetch(`http://127.0.0.1:${port}/health`);
+    // TODO: send shutdown signal
+    console.log(chalk.green('✅ Stopped'));
+  } catch {
+    console.log(chalk.gray('Engine is not running'));
+  }
+}
+
+export async function restart() {
+  await stop();
+  await new Promise(r => setTimeout(r, 1000));
+  await start({ port: '9500' });
+}
+
+export async function status() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`);
+    const data = await res.json();
+
+    console.log(chalk.cyan(`\n  🦑 Squidclaw Status\n  ─────────────────`));
+    console.log(`  Status:    ${chalk.green('● Running')}`);
+    console.log(`  Port:      ${port}`);
+    console.log(`  Agents:    ${data.agents}`);
+    console.log(`  WhatsApp:  ${data.whatsapp} connected`);
+    console.log(`  Uptime:    ${formatUptime(data.uptime)}`);
+    console.log(`  Model:     ${config.ai?.defaultModel || 'not set'}`);
+    console.log(`  Provider:  ${config.ai?.defaultProvider || 'not set'}`);
+    console.log();
+
+    // Get agent details
+    const agentsRes = await fetch(`http://127.0.0.1:${port}/api/agents`);
+    const agents = await agentsRes.json();
+    if (agents.length > 0) {
+      console.log(`  Agents:`);
+      for (const a of agents) {
+        const waIcon = a.whatsappConnected ? chalk.green('📱') : chalk.gray('📱');
+        console.log(`    ${waIcon} ${a.name} (${a.id}) — ${a.model || 'default'} — ${a.status}`);
+      }
+      console.log();
+    }
+  } catch {
+    console.log(chalk.cyan(`\n  🦑 Squidclaw Status\n  ─────────────────`));
+    console.log(`  Status:    ${chalk.red('● Stopped')}`);
+    console.log(`  Start:     ${chalk.cyan('squidclaw start')}\n`);
+  }
+}
+
+function formatUptime(seconds) {
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor((seconds % 86400) / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const parts = [];
+  if (d > 0) parts.push(`${d}d`);
+  if (h > 0) parts.push(`${h}h`);
+  parts.push(`${m}m`);
+  return parts.join(' ');
+}

package/lib/cli/handoff-cmd.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function listHandoffs() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/handoffs`);
+    const handoffs = await res.json();
+    console.log(chalk.cyan(`\n  🤝 Pending Handoffs (${handoffs.length})\n  ──────────────`));
+    for (const h of handoffs) {
+      console.log(`  #${h.id} — Agent: ${h.agent_id} — Contact: ${h.contact_id} — ${h.reason}`);
+    }
+    if (handoffs.length === 0) console.log(chalk.gray('  No pending handoffs'));
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function resolveHandoff(id) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/handoffs/${id}/resolve`, { method: 'POST' });
+    console.log(chalk.green(`✅ Handoff #${id} resolved — agent is back in control`));
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/cli/hours-cmd.js

@@ -0,0 +1,38 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function setHours(schedule, opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}`, {
+      method: 'PUT',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ businessHours: schedule, timezone: opts.timezone || 'UTC' }),
+    });
+    console.log(chalk.green(`✅ Business hours set: ${schedule} (${opts.timezone || 'UTC'})`));
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function showHours(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}`);
+    const agent = await res.json();
+    console.log(chalk.cyan(`\n  ⏰ Business Hours`));
+    console.log(`  Schedule: ${agent.businessHours || '24/7'}`);
+    console.log(`  Timezone: ${agent.timezone || 'UTC'}\n`);
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function setAlwaysOn(opts) {
+  await setHours(null, opts);
+  console.log(chalk.green('✅ 24/7 mode — no business hours'));
+}