squidclaw 2.3.0 → 2.5.0

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

@@ -73,8 +73,9 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
         return result;
       }
 
-      // File attachment (pptx, etc)
+      // File attachment (pptx, excel, pdf, html)
       if (toolResult.toolUsed && toolResult.filePath) {
+        logger.info('agent', 'FILE TOOL: ' + toolResult.toolName + ' -> ' + toolResult.filePath);
         result.filePath = toolResult.filePath;
         result.fileName = toolResult.fileName;
         result.messages = [toolResult.toolResult || 'Here\'s your file! 📎'];

package/lib/engine.js

@@ -226,6 +226,18 @@ export class SquidclawEngine {
       if (pending.c > 0) console.log(`  ⏰ Reminders: ${pending.c} pending`);
     } catch {}
 
+    // Sessions
+    try {
+      const { SessionManager } = await import('./features/sessions.js');
+      this.sessions = new SessionManager(this.storage, this);
+    } catch (err) { logger.error('engine', 'Sessions init failed: ' + err.message); }
+
+    // Cron jobs
+    try {
+      const { CronManager } = await import('./features/cron.js');
+      this.cron = new CronManager(this.storage, this);
+    } catch (err) { logger.error('engine', 'Cron init failed: ' + err.message); }
+
     // Auto-memory
     try {
       const { AutoMemory } = await import('./features/auto-memory.js');

package/lib/features/cron.js

@@ -0,0 +1,217 @@
+/**
+ * 🦑 Cron System
+ * Persistent scheduled jobs — survives restarts
+ */
+
+import { logger } from '../core/logger.js';
+
+export class CronManager {
+  constructor(storage, engine) {
+    this.storage = storage;
+    this.engine = engine;
+    this.timers = new Map();
+    this._initDb();
+    this._loadJobs();
+    this._startTicker();
+  }
+
+  _initDb() {
+    this.storage.db.exec(`
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        schedule TEXT NOT NULL,
+        action TEXT NOT NULL,
+        action_data TEXT DEFAULT '',
+        platform TEXT DEFAULT 'telegram',
+        metadata TEXT DEFAULT '{}',
+        enabled INTEGER DEFAULT 1,
+        last_run TEXT,
+        next_run TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+  }
+
+  /**
+   * Schedule types:
+   * - every:5m / every:1h / every:24h — interval
+   * - daily:09:00 — every day at HH:MM UTC
+   * - weekly:fri:09:00 — every week on day at HH:MM UTC
+   * - monthly:1:09:00 — every month on day at HH:MM UTC
+   * - cron:* * * * * — standard cron expression (min hour dom mon dow)
+   */
+  add(agentId, contactId, name, schedule, action, actionData, platform, metadata) {
+    const id = 'cron_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+    const nextRun = this._calcNextRun(schedule);
+
+    this.storage.db.prepare(
+      'INSERT INTO cron_jobs (id, agent_id, contact_id, name, schedule, action, action_data, platform, metadata, next_run) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
+    ).run(id, agentId, contactId, name, schedule, action, actionData || '', platform || 'telegram', JSON.stringify(metadata || {}), nextRun);
+
+    logger.info('cron', `Added job ${id}: "${name}" schedule=${schedule} next=${nextRun}`);
+    return { id, name, schedule, nextRun };
+  }
+
+  list(agentId, contactId) {
+    return this.storage.db.prepare(
+      'SELECT * FROM cron_jobs WHERE agent_id = ? AND contact_id = ? ORDER BY created_at'
+    ).all(agentId, contactId);
+  }
+
+  listAll(agentId) {
+    return this.storage.db.prepare(
+      'SELECT * FROM cron_jobs WHERE agent_id = ? ORDER BY created_at'
+    ).all(agentId);
+  }
+
+  remove(id) {
+    this.storage.db.prepare('DELETE FROM cron_jobs WHERE id = ?').run(id);
+    logger.info('cron', `Removed job ${id}`);
+  }
+
+  toggle(id, enabled) {
+    this.storage.db.prepare('UPDATE cron_jobs SET enabled = ? WHERE id = ?').run(enabled ? 1 : 0, id);
+  }
+
+  // ── Ticker — runs every 60 seconds ──
+
+  _startTicker() {
+    this._tick(); // run once immediately
+    this._interval = setInterval(() => this._tick(), 60000);
+  }
+
+  _tick() {
+    const now = new Date().toISOString().slice(0, 16);
+    const due = this.storage.db.prepare(
+      "SELECT * FROM cron_jobs WHERE enabled = 1 AND next_run <= ?"
+    ).all(now);
+
+    for (const job of due) {
+      this._execute(job);
+      // Update next_run
+      const nextRun = this._calcNextRun(job.schedule);
+      this.storage.db.prepare(
+        'UPDATE cron_jobs SET last_run = ?, next_run = ? WHERE id = ?'
+      ).run(now, nextRun, job.id);
+    }
+  }
+
+  async _execute(job) {
+    logger.info('cron', `Executing job ${job.id}: "${job.name}"`);
+
+    try {
+      const metadata = JSON.parse(job.metadata || '{}');
+
+      if (job.action === 'message') {
+        // Send a message
+        const msg = '🔄 *Scheduled: ' + job.name + '*\n\n' + (job.action_data || '');
+        await this._send(job.agent_id, job.contact_id, msg, job.platform, metadata);
+      }
+      else if (job.action === 'briefing') {
+        // Send daily briefing
+        try {
+          const { generateBriefing } = await import('./daily-briefing.js');
+          const briefing = await generateBriefing(this.engine, job.agent_id);
+          await this._send(job.agent_id, job.contact_id, briefing, job.platform, metadata);
+        } catch (err) {
+          await this._send(job.agent_id, job.contact_id, '☀️ Good morning! (Briefing failed: ' + err.message + ')', job.platform, metadata);
+        }
+      }
+      else if (job.action === 'ai') {
+        // Run AI prompt and send result
+        const messages = [
+          { role: 'system', content: 'You are a helpful assistant. Complete this task concisely.' },
+          { role: 'user', content: job.action_data },
+        ];
+        const response = await this.engine.aiGateway.chat(messages, {
+          model: this.engine.config.ai?.defaultModel,
+        });
+        await this._send(job.agent_id, job.contact_id, response.content, job.platform, metadata);
+      }
+      else if (job.action === 'remind') {
+        await this._send(job.agent_id, job.contact_id, '⏰ *Reminder:* ' + (job.action_data || job.name), job.platform, metadata);
+      }
+    } catch (err) {
+      logger.error('cron', `Job ${job.id} failed: ${err.message}`);
+    }
+  }
+
+  async _send(agentId, contactId, message, platform, metadata) {
+    if (platform === 'telegram' && this.engine.telegramManager) {
+      await this.engine.telegramManager.sendMessage(agentId, contactId, message, metadata);
+    } else if (this.engine.whatsappManager) {
+      await this.engine.whatsappManager.sendMessage(agentId, contactId, message);
+    }
+  }
+
+  // ── Schedule Parser ──
+
+  _calcNextRun(schedule) {
+    const now = new Date();
+
+    // every:5m / every:1h / every:24h
+    const everyMatch = schedule.match(/^every:(\d+)(m|h|d)$/);
+    if (everyMatch) {
+      const num = parseInt(everyMatch[1]);
+      const unit = everyMatch[2];
+      const ms = unit === 'm' ? num * 60000 : unit === 'h' ? num * 3600000 : num * 86400000;
+      return new Date(now.getTime() + ms).toISOString().slice(0, 16);
+    }
+
+    // daily:09:00
+    const dailyMatch = schedule.match(/^daily:(\d{2}):(\d{2})$/);
+    if (dailyMatch) {
+      const target = new Date(now);
+      target.setUTCHours(parseInt(dailyMatch[1]), parseInt(dailyMatch[2]), 0, 0);
+      if (target <= now) target.setDate(target.getDate() + 1);
+      return target.toISOString().slice(0, 16);
+    }
+
+    // weekly:fri:09:00
+    const weeklyMatch = schedule.match(/^weekly:(\w{3}):(\d{2}):(\d{2})$/);
+    if (weeklyMatch) {
+      const days = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+      const targetDay = days[weeklyMatch[1].toLowerCase()] ?? 0;
+      const target = new Date(now);
+      target.setUTCHours(parseInt(weeklyMatch[2]), parseInt(weeklyMatch[3]), 0, 0);
+      let diff = targetDay - target.getUTCDay();
+      if (diff < 0 || (diff === 0 && target <= now)) diff += 7;
+      target.setDate(target.getDate() + diff);
+      return target.toISOString().slice(0, 16);
+    }
+
+    // monthly:1:09:00
+    const monthlyMatch = schedule.match(/^monthly:(\d+):(\d{2}):(\d{2})$/);
+    if (monthlyMatch) {
+      const target = new Date(now);
+      target.setUTCDate(parseInt(monthlyMatch[1]));
+      target.setUTCHours(parseInt(monthlyMatch[2]), parseInt(monthlyMatch[3]), 0, 0);
+      if (target <= now) target.setMonth(target.getMonth() + 1);
+      return target.toISOString().slice(0, 16);
+    }
+
+    // cron expression (basic: min hour dom mon dow)
+    const cronMatch = schedule.match(/^cron:(.+)$/);
+    if (cronMatch) {
+      // Simple next-minute for cron — full parser would be heavy
+      return new Date(now.getTime() + 60000).toISOString().slice(0, 16);
+    }
+
+    // Default: 1 hour
+    return new Date(now.getTime() + 3600000).toISOString().slice(0, 16);
+  }
+
+  _loadJobs() {
+    const count = this.storage.db.prepare("SELECT COUNT(*) as c FROM cron_jobs WHERE enabled = 1").get()?.c || 0;
+    if (count > 0) {
+      logger.info('cron', `Loaded ${count} active cron jobs`);
+    }
+  }
+
+  stop() {
+    if (this._interval) clearInterval(this._interval);
+  }
+}

package/lib/features/reminders.js

@@ -68,7 +68,7 @@ export class ReminderManager {
   }
 
   async _fire(reminder) {
-    logger.info('reminders', `Firing reminder ${reminder.id} for ${reminder.contact_id}`);
+    logger.info('reminders', `🔔 FIRING reminder ${reminder.id} for ${reminder.contact_id}: ${reminder.message}`);
     
     // Mark as fired
     try {
@@ -95,6 +95,7 @@ export class ReminderManager {
    * @param {object} metadata - chat metadata for sending
    */
   add(agentId, contactId, message, fireAt, platform = 'telegram', metadata = {}) {
+    logger.info('reminders', `📝 ADDING reminder for ${contactId}: ${message} at ${fireAt}`);
     const id = 'rem_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
     const fireAtStr = typeof fireAt === 'string' ? fireAt : fireAt.toISOString().replace('Z', '');
 

package/lib/features/sessions.js

@@ -0,0 +1,269 @@
+/**
+ * 🦑 Session Manager
+ * Multiple isolated conversations per agent
+ * Types: main (default), isolated (fresh context), thread (linked to parent)
+ */
+
+import { logger } from '../core/logger.js';
+import crypto from 'crypto';
+
+export class SessionManager {
+  constructor(storage, engine) {
+    this.storage = storage;
+    this.engine = engine;
+    this.active = new Map(); // sessionKey -> session
+    this._initDb();
+  }
+
+  _initDb() {
+    this.storage.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        type TEXT DEFAULT 'main',
+        label TEXT,
+        parent_id TEXT,
+        model TEXT,
+        system_prompt TEXT,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        metadata TEXT DEFAULT '{}'
+      );
+      CREATE TABLE IF NOT EXISTS session_messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tokens INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (session_id) REFERENCES sessions(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_messages_sid ON session_messages(session_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id, contact_id);
+    `);
+  }
+
+  // ── Session CRUD ──
+
+  create(agentId, contactId, options = {}) {
+    const id = 'sess_' + crypto.randomBytes(6).toString('hex');
+    const type = options.type || 'main';
+    const label = options.label || null;
+    const parentId = options.parentId || null;
+    const model = options.model || null;
+    const systemPrompt = options.systemPrompt || null;
+
+    this.storage.db.prepare(
+      'INSERT INTO sessions (id, agent_id, contact_id, type, label, parent_id, model, system_prompt, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
+    ).run(id, agentId, contactId, type, label, parentId, model, systemPrompt, JSON.stringify(options.metadata || {}));
+
+    const session = { id, agentId, contactId, type, label, parentId, model, systemPrompt, status: 'active' };
+    this.active.set(id, session);
+
+    logger.info('sessions', `Created ${type} session ${id}${label ? ' [' + label + ']' : ''}`);
+    return session;
+  }
+
+  get(sessionId) {
+    const cached = this.active.get(sessionId);
+    if (cached) return cached;
+
+    const row = this.storage.db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
+    if (row) {
+      this.active.set(row.id, row);
+      return row;
+    }
+    return null;
+  }
+
+  /**
+   * Get or create main session for a contact
+   */
+  getMain(agentId, contactId) {
+    let session = this.storage.db.prepare(
+      "SELECT * FROM sessions WHERE agent_id = ? AND contact_id = ? AND type = 'main' AND status = 'active' LIMIT 1"
+    ).get(agentId, contactId);
+
+    if (!session) {
+      session = this.create(agentId, contactId, { type: 'main', label: 'Main' });
+    }
+    return session;
+  }
+
+  /**
+   * Spawn an isolated session
+   */
+  spawn(agentId, contactId, options = {}) {
+    return this.create(agentId, contactId, {
+      type: options.type || 'isolated',
+      label: options.label || options.task?.slice(0, 50),
+      parentId: options.parentId,
+      model: options.model,
+      systemPrompt: options.systemPrompt || (options.task ? 
+        'You are a focused sub-agent. Complete this task concisely:\n\n' + options.task : null),
+      metadata: { task: options.task, timeout: options.timeout },
+    });
+  }
+
+  /**
+   * List sessions for a contact
+   */
+  list(agentId, contactId, options = {}) {
+    let query = 'SELECT * FROM sessions WHERE agent_id = ?';
+    const params = [agentId];
+
+    if (contactId) {
+      query += ' AND contact_id = ?';
+      params.push(contactId);
+    }
+    if (options.type) {
+      query += ' AND type = ?';
+      params.push(options.type);
+    }
+    if (options.status || !options.includeEnded) {
+      query += ' AND status = ?';
+      params.push(options.status || 'active');
+    }
+
+    query += ' ORDER BY created_at DESC';
+    if (options.limit) {
+      query += ' LIMIT ?';
+      params.push(options.limit);
+    }
+
+    return this.storage.db.prepare(query).all(...params);
+  }
+
+  /**
+   * End a session
+   */
+  end(sessionId) {
+    this.storage.db.prepare("UPDATE sessions SET status = 'ended', updated_at = datetime('now') WHERE id = ?").run(sessionId);
+    this.active.delete(sessionId);
+    logger.info('sessions', `Ended session ${sessionId}`);
+  }
+
+  // ── Session Messages ──
+
+  addMessage(sessionId, role, content, tokens = 0) {
+    this.storage.db.prepare(
+      'INSERT INTO session_messages (session_id, role, content, tokens) VALUES (?, ?, ?, ?)'
+    ).run(sessionId, role, content, tokens);
+
+    this.storage.db.prepare("UPDATE sessions SET updated_at = datetime('now') WHERE id = ?").run(sessionId);
+  }
+
+  getHistory(sessionId, limit = 50) {
+    return this.storage.db.prepare(
+      'SELECT role, content, created_at FROM session_messages WHERE session_id = ? ORDER BY created_at ASC LIMIT ?'
+    ).all(sessionId, limit);
+  }
+
+  clearHistory(sessionId) {
+    this.storage.db.prepare('DELETE FROM session_messages WHERE session_id = ?').run(sessionId);
+  }
+
+  // ── Session AI Processing ──
+
+  async process(sessionId, message) {
+    const session = this.get(sessionId);
+    if (!session) throw new Error('Session not found: ' + sessionId);
+
+    // Save user message
+    this.addMessage(sessionId, 'user', message);
+
+    // Build messages array
+    const history = this.getHistory(sessionId);
+    const model = session.model || this.engine.config.ai?.defaultModel;
+
+    // Get system prompt
+    let systemPrompt = session.system_prompt || session.systemPrompt;
+    if (!systemPrompt && session.type === 'main') {
+      // Use agent's normal prompt for main sessions
+      const agent = this.engine.agents?.get(session.agent_id);
+      if (agent?.promptBuilder) {
+        systemPrompt = await agent.promptBuilder.build(agent, session.contact_id, message);
+      }
+    }
+
+    const messages = [];
+    if (systemPrompt) messages.push({ role: 'system', content: systemPrompt });
+    messages.push(...history.map(h => ({ role: h.role === 'system' ? 'user' : h.role, content: h.content })));
+
+    // Call AI
+    const response = await this.engine.aiGateway.chat(messages, {
+      model,
+      fallbackChain: this.engine.config.ai?.fallbackChain,
+    });
+
+    // Save assistant response
+    this.addMessage(sessionId, 'assistant', response.content, response.outputTokens);
+
+    // Track usage
+    await this.storage.trackUsage(session.agent_id, response.model, response.inputTokens, response.outputTokens, response.costUsd);
+
+    logger.info('sessions', `Session ${sessionId} processed (${response.model}, ${response.outputTokens} tokens)`);
+
+    return {
+      content: response.content,
+      model: response.model,
+      tokens: response.inputTokens + response.outputTokens,
+      cost: response.costUsd,
+      sessionId,
+    };
+  }
+
+  // ── Sub-agent spawning with auto-completion ──
+
+  async runTask(agentId, contactId, task, options = {}) {
+    const session = this.spawn(agentId, contactId, {
+      type: 'isolated',
+      task,
+      model: options.model,
+      label: options.label || task.slice(0, 50),
+    });
+
+    const timeout = options.timeout || 60000;
+
+    try {
+      const result = await Promise.race([
+        this.process(session.id, task),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Task timeout')), timeout)),
+      ]);
+
+      this.end(session.id);
+      return { ...result, status: 'complete' };
+    } catch (err) {
+      this.end(session.id);
+      return { content: 'Task failed: ' + err.message, status: 'error', sessionId: session.id };
+    }
+  }
+
+  // ── Send message to another session ──
+
+  async send(targetSessionId, message) {
+    const session = this.get(targetSessionId);
+    if (!session) throw new Error('Session not found');
+    return this.process(targetSessionId, message);
+  }
+
+  // ── Stats ──
+
+  getStats(agentId) {
+    const active = this.storage.db.prepare(
+      "SELECT COUNT(*) as c FROM sessions WHERE agent_id = ? AND status = 'active'"
+    ).get(agentId)?.c || 0;
+
+    const total = this.storage.db.prepare(
+      'SELECT COUNT(*) as c FROM sessions WHERE agent_id = ?'
+    ).get(agentId)?.c || 0;
+
+    const messages = this.storage.db.prepare(
+      'SELECT COUNT(*) as c FROM session_messages sm JOIN sessions s ON sm.session_id = s.id WHERE s.agent_id = ?'
+    ).get(agentId)?.c || 0;
+
+    return { active, total, messages };
+  }
+}

package/lib/middleware/commands.js

@@ -145,6 +145,64 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/sessions') {
+    if (!ctx.engine.sessions) { await ctx.reply('❌ Sessions not available'); return; }
+    const args = msg.slice(10).trim();
+    
+    if (args.startsWith('new ')) {
+      const task = args.slice(4).trim();
+      await ctx.reply('🔄 Spawning session: ' + task.slice(0, 50) + '...');
+      const result = await ctx.engine.sessions.runTask(ctx.agentId, ctx.contactId, task);
+      await ctx.reply('✅ *Session Complete*\n\n' + result.content.slice(0, 2000));
+      return;
+    }
+    
+    if (args === 'stats') {
+      const stats = ctx.engine.sessions.getStats(ctx.agentId);
+      await ctx.reply('📊 *Sessions*\n\n🟢 Active: ' + stats.active + '\n📝 Total: ' + stats.total + '\n💬 Messages: ' + stats.messages);
+      return;
+    }
+    
+    if (args.startsWith('end ')) {
+      ctx.engine.sessions.end(args.slice(4).trim());
+      await ctx.reply('✅ Session ended');
+      return;
+    }
+
+    const sessions = ctx.engine.sessions.list(ctx.agentId, ctx.contactId, { limit: 10 });
+    if (sessions.length === 0) { await ctx.reply('📋 No active sessions'); return; }
+    const lines = sessions.map(s =>
+      (s.status === 'active' ? '🟢' : '⚫') + ' *' + (s.label || 'Untitled') + '*\n   Type: ' + s.type + '\n   ID: `' + s.id + '`'
+    );
+    await ctx.reply('📋 *Sessions*\n\n' + lines.join('\n\n') + '\n\n/sessions new <task> — spawn\n/sessions end <id> — close\n/sessions stats');
+    return;
+  }
+
+  if (cmd === '/cron') {
+    const args = msg.slice(6).trim();
+    if (!ctx.engine.cron) { await ctx.reply('❌ Cron not available'); return; }
+    
+    if (!args || args === 'list') {
+      const jobs = ctx.engine.cron.listAll(ctx.agentId);
+      if (jobs.length === 0) { await ctx.reply('⏰ No scheduled jobs'); return; }
+      const lines = jobs.map(j => 
+        (j.enabled ? '✅' : '⏸️') + ' *' + j.name + '*\n   ' + j.schedule + ' → ' + j.action + '\n   Next: ' + (j.next_run || '?') + '\n   ID: `' + j.id + '`'
+      );
+      await ctx.reply('⏰ *Cron Jobs*\n\n' + lines.join('\n\n'));
+      return;
+    }
+    
+    if (args.startsWith('remove ') || args.startsWith('delete ')) {
+      const id = args.split(' ')[1];
+      ctx.engine.cron.remove(id);
+      await ctx.reply('✅ Removed cron job ' + id);
+      return;
+    }
+
+    await ctx.reply('Usage:\n/cron — list jobs\n/cron remove <id> — delete job\n\nOr tell me naturally: "Every morning at 9am send me a briefing"');
+    return;
+  }
+
   if (cmd === '/allow') {
     const args = msg.slice(7).trim();
     if (!args) { await ctx.reply('Usage: /allow <user_id or phone>'); return; }

package/lib/middleware/response-sender.js

@@ -29,8 +29,9 @@ export async function responseSenderMiddleware(ctx, next) {
 
   // Send via appropriate channel
   if (ctx.platform === 'telegram' && tm) {
-    // Send file attachment (pptx, etc)
+    // Send file attachment (pptx, excel, pdf, html)
     if (response.filePath) {
+      logger.info('sender', 'SENDING FILE: ' + response.filePath);
       try {
         await tm.sendDocument(agentId, contactId, response.filePath, response.fileName, response.messages?.[0] || '');
         await next();

package/lib/tools/excel.js

@@ -0,0 +1,136 @@
+/**
+ * 🦑 Excel Generator
+ * Create .xlsx spreadsheets
+ */
+
+import { logger } from '../core/logger.js';
+import { mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class ExcelGenerator {
+  constructor() {
+    this.outputDir = '/tmp/squidclaw-files';
+    mkdirSync(this.outputDir, { recursive: true });
+  }
+
+  async create(title, sheets, options = {}) {
+    const ExcelJS = (await import('exceljs')).default;
+    const wb = new ExcelJS.Workbook();
+    wb.creator = 'Squidclaw AI 🦑';
+    wb.created = new Date();
+
+    const themes = {
+      blue:   { header: '2563EB', headerFont: 'FFFFFF', alt: 'EFF6FF', border: 'BFDBFE' },
+      green:  { header: '059669', headerFont: 'FFFFFF', alt: 'ECFDF5', border: 'A7F3D0' },
+      dark:   { header: '1F2937', headerFont: 'FFFFFF', alt: 'F3F4F6', border: 'D1D5DB' },
+      red:    { header: 'DC2626', headerFont: 'FFFFFF', alt: 'FEF2F2', border: 'FECACA' },
+      saudi:  { header: '166534', headerFont: 'FFFFFF', alt: 'F0FDF4', border: 'BBF7D0' },
+      corporate: { header: '1E40AF', headerFont: 'FFFFFF', alt: 'F8FAFC', border: 'CBD5E1' },
+    };
+    const theme = themes[options.theme] || themes.corporate;
+
+    for (const sheet of sheets) {
+      const ws = wb.addWorksheet(sheet.name || 'Sheet');
+      
+      if (!sheet.rows || sheet.rows.length === 0) continue;
+
+      // Auto-detect columns from first row
+      const headers = sheet.rows[0];
+      
+      // Set columns with auto-width
+      ws.columns = headers.map((h, i) => ({
+        header: String(h),
+        key: 'col' + i,
+        width: Math.max(String(h).length + 4, 15),
+      }));
+
+      // Style header row
+      const headerRow = ws.getRow(1);
+      headerRow.height = 28;
+      headerRow.eachCell((cell) => {
+        cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: theme.header } };
+        cell.font = { color: { argb: theme.headerFont }, bold: true, size: 12 };
+        cell.alignment = { vertical: 'middle', horizontal: 'center' };
+        cell.border = {
+          bottom: { style: 'medium', color: { argb: theme.border } },
+        };
+      });
+
+      // Data rows
+      for (let r = 1; r < sheet.rows.length; r++) {
+        const row = sheet.rows[r];
+        const wsRow = ws.addRow(row.reduce((obj, val, i) => { obj['col' + i] = val; return obj; }, {}));
+        wsRow.height = 22;
+        
+        wsRow.eachCell((cell) => {
+          if (r % 2 === 0) {
+            cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: theme.alt } };
+          }
+          cell.alignment = { vertical: 'middle' };
+          cell.border = {
+            bottom: { style: 'thin', color: { argb: theme.border } },
+          };
+          // Auto-detect numbers
+          const val = cell.value;
+          if (typeof val === 'string' && !isNaN(val.replace(/[,$%]/g, ''))) {
+            cell.value = parseFloat(val.replace(/[,$]/g, ''));
+            if (val.includes('%')) cell.numFmt = '0.0%';
+            else if (val.includes('$')) cell.numFmt = '$#,##0.00';
+            else cell.numFmt = '#,##0';
+          }
+        });
+      }
+
+      // Auto-filter
+      if (sheet.rows.length > 1) {
+        ws.autoFilter = { from: 'A1', to: String.fromCharCode(64 + headers.length) + '1' };
+      }
+
+      // Freeze header
+      ws.views = [{ state: 'frozen', ySplit: 1 }];
+    }
+
+    const filename = title.replace(/[^a-zA-Z0-9\u0600-\u06FF ]/g, '').replace(/\s+/g, '_').slice(0, 50) + '.xlsx';
+    const filepath = join(this.outputDir, filename);
+    await wb.xlsx.writeFile(filepath);
+
+    logger.info('excel', `Created: ${filepath}`);
+    return { filepath, filename, sheetCount: sheets.length };
+  }
+
+  /**
+   * Parse AI content: rows separated by newlines, cells by | or ,
+   */
+  static parseContent(text) {
+    const sheets = [];
+    const sections = text.split(/^### /gm).filter(s => s.trim());
+
+    if (sections.length === 0) {
+      // Single sheet
+      sheets.push({ name: 'Data', rows: ExcelGenerator._parseRows(text) });
+    } else {
+      for (const section of sections) {
+        const lines = section.trim().split('\n');
+        const name = lines[0].trim();
+        sheets.push({ name, rows: ExcelGenerator._parseRows(lines.slice(1).join('\n')) });
+      }
+    }
+    return sheets;
+  }
+
+  static _parseRows(text) {
+    const rows = [];
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || /^[-|:=]+$/.test(trimmed)) continue;
+      if (trimmed.includes('|')) {
+        rows.push(trimmed.split('|').map(c => c.trim()).filter(Boolean));
+      } else if (trimmed.includes(',')) {
+        rows.push(trimmed.split(',').map(c => c.trim()));
+      } else if (trimmed.includes('\t')) {
+        rows.push(trimmed.split('\t').map(c => c.trim()));
+      }
+    }
+    return rows;
+  }
+}

package/lib/tools/html.js

@@ -0,0 +1,148 @@
+/**
+ * 🦑 HTML Generator
+ * Create styled HTML pages/reports
+ */
+
+import { logger } from '../core/logger.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class HtmlGenerator {
+  constructor() {
+    this.outputDir = '/tmp/squidclaw-files';
+    mkdirSync(this.outputDir, { recursive: true });
+  }
+
+  create(title, content, options = {}) {
+    const theme = options.theme || 'light';
+    const isDark = ['dark', 'ocean', 'gradient'].includes(theme);
+
+    const css = isDark ? `
+      body { background: #0d1117; color: #c9d1d9; }
+      h1 { color: #58a6ff; border-bottom: 2px solid #58a6ff; }
+      h2 { color: #58a6ff; }
+      h3 { color: #8b949e; }
+      a { color: #58a6ff; }
+      blockquote { border-left: 3px solid #58a6ff; color: #8b949e; }
+      table th { background: #161b22; color: #58a6ff; }
+      table td { border-color: #30363d; }
+      tr:nth-child(even) { background: #161b22; }
+      code { background: #161b22; color: #f0883e; }
+      .accent { color: #58a6ff; }
+    ` : `
+      body { background: #ffffff; color: #1f2937; }
+      h1 { color: #1e40af; border-bottom: 2px solid #2563eb; }
+      h2 { color: #1e40af; }
+      h3 { color: #374151; }
+      a { color: #2563eb; }
+      blockquote { border-left: 3px solid #2563eb; color: #6b7280; }
+      table th { background: #2563eb; color: white; }
+      table td { border-color: #e5e7eb; }
+      tr:nth-child(even) { background: #f8fafc; }
+      code { background: #f1f5f9; color: #dc2626; }
+      .accent { color: #2563eb; }
+    `;
+
+    // Convert markdown-like content to HTML
+    let html = this._markdownToHtml(content);
+
+    const page = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${this._escape(title)}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; line-height: 1.7; padding: 40px; max-width: 900px; margin: 0 auto; }
+    h1 { font-size: 2.2em; margin-bottom: 8px; padding-bottom: 12px; }
+    h2 { font-size: 1.6em; margin-top: 32px; margin-bottom: 12px; }
+    h3 { font-size: 1.2em; margin-top: 24px; margin-bottom: 8px; }
+    p { margin-bottom: 12px; }
+    ul, ol { margin: 12px 0; padding-left: 28px; }
+    li { margin-bottom: 6px; }
+    blockquote { padding: 12px 20px; margin: 16px 0; font-style: italic; }
+    table { width: 100%; border-collapse: collapse; margin: 16px 0; }
+    th, td { padding: 10px 14px; text-align: left; }
+    td { border-bottom: 1px solid; }
+    th { font-weight: 600; text-transform: uppercase; font-size: 0.85em; letter-spacing: 0.5px; }
+    code { padding: 2px 6px; border-radius: 4px; font-size: 0.9em; }
+    pre { padding: 16px; border-radius: 8px; overflow-x: auto; margin: 16px 0; }
+    img { max-width: 100%; border-radius: 8px; }
+    hr { border: none; border-top: 1px solid #e5e7eb; margin: 24px 0; }
+    .meta { font-size: 0.85em; opacity: 0.6; margin-top: 40px; text-align: center; }
+    ${css}
+  </style>
+</head>
+<body>
+  <h1>${this._escape(title)}</h1>
+  <p style="opacity:0.5;font-size:0.9em">${new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' })}</p>
+  ${html}
+  <p class="meta">Created with Squidclaw AI 🦑</p>
+</body>
+</html>`;
+
+    const filename = title.replace(/[^a-zA-Z0-9\u0600-\u06FF ]/g, '').replace(/\s+/g, '_').slice(0, 50) + '.html';
+    const filepath = join(this.outputDir, filename);
+    writeFileSync(filepath, page);
+
+    logger.info('html', `Created: ${filepath}`);
+    return { filepath, filename };
+  }
+
+  _markdownToHtml(md) {
+    let html = md
+      .replace(/^## (.+)$/gm, '<h2>$1</h2>')
+      .replace(/^### (.+)$/gm, '<h3>$1</h3>')
+      .replace(/^\> (.+)$/gm, '<blockquote>$1</blockquote>')
+      .replace(/^---$/gm, '<hr>')
+      .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+      .replace(/\*(.+?)\*/g, '<em>$1</em>')
+      .replace(/`(.+?)`/g, '<code>$1</code>')
+      .replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>');
+
+    // Bullet lists
+    const lines = html.split('\n');
+    let result = '';
+    let inList = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('- ') || trimmed.startsWith('• ') || trimmed.startsWith('* ')) {
+        if (!inList) { result += '<ul>'; inList = true; }
+        result += '<li>' + trimmed.replace(/^[-•*]\s*/, '') + '</li>';
+      } else {
+        if (inList) { result += '</ul>'; inList = false; }
+        if (trimmed.startsWith('<h') || trimmed.startsWith('<blockquote') || trimmed.startsWith('<hr') || !trimmed) {
+          result += trimmed;
+        } else if (trimmed.startsWith('|')) {
+          result += this._parseTable(trimmed, lines);
+        } else {
+          result += '<p>' + trimmed + '</p>';
+        }
+      }
+    }
+    if (inList) result += '</ul>';
+
+    return result;
+  }
+
+  _parseTable(firstLine, allLines) {
+    // Find consecutive | lines
+    const tableLines = allLines.filter(l => l.trim().startsWith('|') && !/^[-|:\s]+$/.test(l.trim()));
+    if (tableLines.length === 0) return '';
+
+    let html = '<table>';
+    tableLines.forEach((line, i) => {
+      const cells = line.split('|').filter(c => c.trim()).map(c => c.trim());
+      const tag = i === 0 ? 'th' : 'td';
+      html += '<tr>' + cells.map(c => `<${tag}>${c}</${tag}>`).join('') + '</tr>';
+    });
+    html += '</table>';
+    return html;
+  }
+
+  _escape(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  }
+}

package/lib/tools/pdf.js

@@ -0,0 +1,133 @@
+/**
+ * 🦑 PDF Generator
+ * Create .pdf documents
+ */
+
+import { logger } from '../core/logger.js';
+import { mkdirSync, createWriteStream } from 'fs';
+import { join } from 'path';
+
+export class PdfGenerator {
+  constructor() {
+    this.outputDir = '/tmp/squidclaw-files';
+    mkdirSync(this.outputDir, { recursive: true });
+  }
+
+  async create(title, content, options = {}) {
+    const PDFDocument = (await import('pdfkit')).default;
+
+    const filename = title.replace(/[^a-zA-Z0-9\u0600-\u06FF ]/g, '').replace(/\s+/g, '_').slice(0, 50) + '.pdf';
+    const filepath = join(this.outputDir, filename);
+
+    return new Promise((resolve, reject) => {
+      const doc = new PDFDocument({
+        size: 'A4',
+        margins: { top: 60, bottom: 60, left: 60, right: 60 },
+        info: { Title: title, Author: 'Squidclaw AI 🦑', Creator: 'Squidclaw' },
+      });
+
+      const stream = createWriteStream(filepath);
+      doc.pipe(stream);
+
+      const colors = {
+        title: '#1a1a2e',
+        heading: '#2563eb',
+        text: '#374151',
+        accent: '#2563eb',
+        light: '#6b7280',
+        bg: '#f8fafc',
+      };
+
+      // Header accent bar
+      doc.rect(0, 0, doc.page.width, 8).fill(colors.accent);
+
+      // Title
+      doc.moveDown(1);
+      doc.fontSize(28).fillColor(colors.title).font('Helvetica-Bold').text(title, { align: 'left' });
+      
+      // Subtitle line
+      doc.moveDown(0.3);
+      doc.moveTo(60, doc.y).lineTo(200, doc.y).strokeColor(colors.accent).lineWidth(2).stroke();
+      doc.moveDown(0.5);
+
+      // Date
+      const date = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+      doc.fontSize(10).fillColor(colors.light).font('Helvetica').text(date);
+      doc.moveDown(1.5);
+
+      // Parse and render content
+      const lines = content.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) { doc.moveDown(0.5); continue; }
+
+        // Check for page overflow
+        if (doc.y > doc.page.height - 100) {
+          doc.addPage();
+          doc.rect(0, 0, doc.page.width, 4).fill(colors.accent);
+          doc.moveDown(1);
+        }
+
+        // ## Heading
+        if (trimmed.startsWith('## ')) {
+          doc.moveDown(0.8);
+          doc.fontSize(18).fillColor(colors.heading).font('Helvetica-Bold').text(trimmed.slice(3));
+          doc.moveDown(0.2);
+          doc.moveTo(60, doc.y).lineTo(160, doc.y).strokeColor(colors.accent).lineWidth(1).stroke();
+          doc.moveDown(0.5);
+        }
+        // ### Subheading
+        else if (trimmed.startsWith('### ')) {
+          doc.moveDown(0.5);
+          doc.fontSize(14).fillColor(colors.title).font('Helvetica-Bold').text(trimmed.slice(4));
+          doc.moveDown(0.3);
+        }
+        // - Bullet
+        else if (trimmed.startsWith('- ') || trimmed.startsWith('• ') || trimmed.startsWith('* ')) {
+          const bullet = trimmed.replace(/^[-•*]\s*/, '');
+          doc.fontSize(11).fillColor(colors.text).font('Helvetica');
+          doc.text('●  ' + bullet, { indent: 15, lineGap: 4 });
+        }
+        // **Bold**
+        else if (trimmed.startsWith('**') && trimmed.endsWith('**')) {
+          doc.fontSize(12).fillColor(colors.title).font('Helvetica-Bold').text(trimmed.replace(/\*\*/g, ''));
+        }
+        // > Quote
+        else if (trimmed.startsWith('> ')) {
+          doc.moveDown(0.3);
+          const quoteText = trimmed.slice(2);
+          const qx = doc.x;
+          doc.rect(qx, doc.y, 3, 40).fill(colors.accent);
+          doc.fontSize(11).fillColor(colors.light).font('Helvetica-Oblique').text(quoteText, qx + 15, doc.y - 40 + 5, { width: 420 });
+          doc.moveDown(0.5);
+        }
+        // --- Divider
+        else if (trimmed === '---' || trimmed === '***') {
+          doc.moveDown(0.5);
+          doc.moveTo(60, doc.y).lineTo(doc.page.width - 60, doc.y).strokeColor('#e5e7eb').lineWidth(0.5).stroke();
+          doc.moveDown(0.5);
+        }
+        // Normal text
+        else {
+          doc.fontSize(11).fillColor(colors.text).font('Helvetica').text(trimmed, { lineGap: 4 });
+        }
+      }
+
+      // Footer
+      const pages = doc.bufferedPageRange();
+      for (let i = 0; i < pages.count; i++) {
+        doc.switchToPage(i);
+        doc.fontSize(8).fillColor(colors.light).font('Helvetica');
+        doc.text('Created with Squidclaw AI 🦑', 60, doc.page.height - 40, { width: doc.page.width - 120, align: 'center' });
+        doc.text(String(i + 1), 60, doc.page.height - 40, { width: doc.page.width - 120, align: 'right' });
+      }
+
+      doc.end();
+      stream.on('finish', () => {
+        logger.info('pdf', `Created: ${filepath}`);
+        resolve({ filepath, filename });
+      });
+      stream.on('error', reject);
+    });
+  }
+}

package/lib/tools/router.js

@@ -79,6 +79,49 @@ export class ToolRouter {
       'Example:',
       '---TOOL:pptx_slides:AI Report|dark|## Introduction\n- AI is transforming industries\n- Revenue growing 40% YoY\n\n## Growth [chart:bar]\n- 2020: 50\n- 2021: 80\n- 2022: 120\n- 2023: 200\n\n## Key Stats [stats]\n- 🌍 195 — Countries using AI\n- 💰 $500B — Market size\n- 🚀 40% — Annual growth---');
 
+    tools.push('', '### Spawn Sub-Agent Session',
+      '---TOOL:session_spawn:task description---',
+      'Spawn an isolated AI session to work on a task in the background. Returns when complete.',
+      'Use for: research, analysis, writing, any task that needs focused work.',
+      'Example: ---TOOL:session_spawn:Research the top 5 AI companies in Saudi Arabia and summarize their products---',
+      '', '### List Sessions',
+      '---TOOL:session_list:all---',
+      'Show all active sessions.',
+      '', '### Send to Session',
+      '---TOOL:session_send:session_id|message---',
+      'Send a follow-up message to an existing session.');
+
+    tools.push('', '### Create Excel Spreadsheet (SENDS AS FILE!)',
+      '---TOOL:excel:Title|theme|sheet content---',
+      'Creates .xlsx file and sends it. Theme: blue, green, dark, red, saudi, corporate.',
+      'Content: use | for columns. First row = headers. Separate sheets with ### SheetName.',
+      'Example: ---TOOL:excel:Sales Report|blue|Product|Revenue|Growth\nWidget A|50000|12%\nWidget B|80000|25%---',
+      '', '### Create PDF Document (SENDS AS FILE!)',
+      '---TOOL:pdf:Title|content in markdown---',
+      'Creates .pdf file and sends it. Use ## for headings, - for bullets, > for quotes, --- for dividers.',
+      'Example: ---TOOL:pdf:Meeting Notes|## Summary\n- Discussed Q1 results\n- Action items assigned---',
+      '', '### Create HTML Page (SENDS AS FILE!)',
+      '---TOOL:html:Title|theme|content in markdown---',
+      'Creates .html file and sends it. Themes: light, dark, ocean.',
+      'Example: ---TOOL:html:Report|dark|## Overview\n- Key findings\n- Recommendations---');
+
+    tools.push('', '### Schedule Cron Job',
+      '---TOOL:cron_add:name|schedule|action|data---',
+      'Create a recurring scheduled job. Schedule formats:',
+      '- every:5m / every:1h / every:24h (interval)',
+      '- daily:09:00 (every day at time UTC)',
+      '- weekly:fri:09:00 (every week on day)',
+      '- monthly:1:09:00 (every month on date)',
+      'Actions: message (send text), briefing (daily brief), remind (reminder), ai (run AI prompt)',
+      'Example: ---TOOL:cron_add:Morning Briefing|daily:06:00|briefing|---',
+      'Example: ---TOOL:cron_add:Weekly Report Reminder|weekly:fri:09:00|remind|Submit the weekly report!---',
+      '', '### List Cron Jobs',
+      '---TOOL:cron_list:all---',
+      'Show all scheduled jobs.',
+      '', '### Remove Cron Job',
+      '---TOOL:cron_remove:job_id---',
+      'Remove a scheduled job by ID.');
+
     tools.push('', '### Allow User',
       '---TOOL:allow:user_id_or_phone---',
       'Add someone to the allowlist so they can message you.',
@@ -187,9 +230,16 @@ export class ToolRouter {
       'You already have vision — use it to read text from screenshots, documents, signs, etc.');
 
     tools.push('', '### Set Reminder',
-      '---TOOL:remind:YYYY-MM-DDTHH:MM|Your reminder message---',
-      'Set a reminder to message the user at a specific time. Time must be in UTC.',
-      'Example: ---TOOL:remind:2026-03-03T08:30|Wake up! Time to start the day!---',
+      '---TOOL:remind:TIME|Your reminder message---',
+      'Set a reminder. TIME can be:',
+      '- Relative: 5m, 30m, 1h, 2h, 1d (minutes, hours, days from now)',
+      '- Absolute: 2026-03-03T08:30 (UTC)',
+      '- Natural: tomorrow, tonight',
+      'Examples:',
+      '- ---TOOL:remind:30m|Check the oven!---',
+      '- ---TOOL:remind:2h|Call Ahmed---',
+      '- ---TOOL:remind:2026-03-03T15:00|Meeting time!---',
+      'ALWAYS use this tool when user says "remind me". Do NOT just acknowledge — actually set it.',
       'The user will receive a proactive message at that time even if they are not chatting.');
 
     tools.push('', '**Important:** Use tools when needed. The tool result will be injected into the conversation automatically. Only use one tool per response.');
@@ -208,7 +258,21 @@ export class ToolRouter {
   }
 
   async processResponse(response, agentId) {
-    const toolMatch = response.match(/---TOOL:(\w+):(.+?)---/);
+    const toolMatch = (() => {
+      const startIdx = response.indexOf('---TOOL:');
+      if (startIdx === -1) return null;
+      const afterTag = response.slice(startIdx + 8);
+      const colonIdx = afterTag.indexOf(':');
+      if (colonIdx === -1) return null;
+      const toolName = afterTag.slice(0, colonIdx);
+      const rest = afterTag.slice(colonIdx + 1);
+      // Find the closing --- that's NOT part of markdown (look for last --- or ---END---)
+      let endIdx = rest.lastIndexOf('---');
+      if (endIdx <= 0) return null;
+      const toolArg = rest.slice(0, endIdx);
+      const fullMatch = response.slice(startIdx, startIdx + 8 + colonIdx + 1 + endIdx + 3);
+      return [fullMatch, toolName, toolArg];
+    })();
     if (!toolMatch) return { toolUsed: false, toolResult: null, cleanResponse: response };
 
     const [fullMatch, toolName, toolArg] = toolMatch;
@@ -229,12 +293,31 @@ export class ToolRouter {
           try {
             const pipeIdx = toolArg.indexOf('|');
             if (pipeIdx === -1) {
-              toolResult = 'Invalid reminder format. Use: YYYY-MM-DDTHH:MM|message';
+              toolResult = 'Format: time|message. Example: 30m|Check oven';
               break;
             }
-            const timeStr = toolArg.slice(0, pipeIdx).trim();
+            let timeStr = toolArg.slice(0, pipeIdx).trim();
             const msg = toolArg.slice(pipeIdx + 1).trim();
-            // Store reminder request in result for engine to pick up
+            
+            // Parse relative times
+            const relMatch = timeStr.match(/^(\d+)\s*(m|min|minutes?|h|hr|hours?|d|days?)$/i);
+            if (relMatch) {
+              const num = parseInt(relMatch[1]);
+              const unit = relMatch[2][0].toLowerCase();
+              const ms = unit === 'm' ? num * 60000 : unit === 'h' ? num * 3600000 : num * 86400000;
+              const fireDate = new Date(Date.now() + ms);
+              timeStr = fireDate.toISOString().slice(0, 16);
+            } else if (timeStr.toLowerCase() === 'tomorrow') {
+              const d = new Date(Date.now() + 86400000);
+              d.setUTCHours(9, 0, 0, 0);
+              timeStr = d.toISOString().slice(0, 16);
+            } else if (timeStr.toLowerCase() === 'tonight') {
+              const d = new Date();
+              d.setUTCHours(18, 0, 0, 0);
+              if (d < new Date()) d.setDate(d.getDate() + 1);
+              timeStr = d.toISOString().slice(0, 16);
+            }
+            
             return { toolUsed: true, toolName: 'remind', reminderTime: timeStr, reminderMessage: msg, cleanResponse };
           } catch (err) {
             toolResult = 'Failed to set reminder: ' + err.message;
@@ -291,6 +374,123 @@ export class ToolRouter {
           }
           break;
         }
+        case 'session_spawn':
+        case 'spawn_session':
+        case 'subagent': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const result = await this._engine.sessions.runTask(
+              agentId, this._currentContactId || 'unknown', toolArg, { timeout: 120000 }
+            );
+            toolResult = result.status === 'complete' ?
+              'Sub-agent result:\n\n' + result.content :
+              'Sub-agent failed: ' + result.content;
+          } catch (err) { toolResult = 'Spawn failed: ' + err.message; }
+          break;
+        }
+        case 'session_list': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const sessions = this._engine.sessions.list(agentId, this._currentContactId);
+            if (sessions.length === 0) { toolResult = 'No active sessions'; break; }
+            toolResult = sessions.map(s =>
+              (s.status === 'active' ? '🟢' : '⚫') + ' ' + (s.label || s.id) + ' (' + s.type + ')\n   ID: ' + s.id
+            ).join('\n');
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'session_send': {
+          try {
+            if (!this._engine?.sessions) { toolResult = 'Sessions not available'; break; }
+            const pipeIdx = toolArg.indexOf('|');
+            if (pipeIdx === -1) { toolResult = 'Format: session_id|message'; break; }
+            const sessId = toolArg.slice(0, pipeIdx).trim();
+            const msg = toolArg.slice(pipeIdx + 1).trim();
+            const result = await this._engine.sessions.send(sessId, msg);
+            toolResult = 'Session response:\n\n' + result.content;
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'excel':
+        case 'xlsx':
+        case 'spreadsheet': {
+          try {
+            const { ExcelGenerator } = await import('./excel.js');
+            const gen = new ExcelGenerator();
+            const parts = toolArg.split('|');
+            let title, themeName, sheetContent;
+            if (parts.length >= 3) {
+              title = parts[0].trim();
+              themeName = parts[1].trim();
+              sheetContent = parts.slice(2).join('|');
+            } else {
+              title = parts[0]?.trim() || 'Spreadsheet';
+              sheetContent = parts.slice(1).join('|');
+              themeName = 'corporate';
+            }
+            const sheets = ExcelGenerator.parseContent(sheetContent);
+            const result = await gen.create(title, sheets, { theme: themeName });
+            return { toolUsed: true, toolName: 'excel', toolResult: 'Excel created: ' + result.filename, filePath: result.filepath, fileName: result.filename, cleanResponse };
+          } catch (err) { toolResult = 'Excel failed: ' + err.message; }
+          break;
+        }
+        case 'pdf':
+        case 'document': {
+          try {
+            const { PdfGenerator } = await import('./pdf.js');
+            const gen = new PdfGenerator();
+            const pipeIdx = toolArg.indexOf('|');
+            const title = pipeIdx > -1 ? toolArg.slice(0, pipeIdx).trim() : 'Document';
+            const content = pipeIdx > -1 ? toolArg.slice(pipeIdx + 1) : toolArg;
+            const result = await gen.create(title, content);
+            return { toolUsed: true, toolName: 'pdf', toolResult: 'PDF created: ' + result.filename, filePath: result.filepath, fileName: result.filename, cleanResponse };
+          } catch (err) { toolResult = 'PDF failed: ' + err.message; }
+          break;
+        }
+        case 'html':
+        case 'webpage': {
+          try {
+            const { HtmlGenerator } = await import('./html.js');
+            const gen = new HtmlGenerator();
+            const parts = toolArg.split('|');
+            const title = parts[0]?.trim() || 'Page';
+            const themeName = parts.length >= 3 ? parts[1].trim() : 'light';
+            const content = parts.length >= 3 ? parts.slice(2).join('|') : parts.slice(1).join('|');
+            const result = gen.create(title, content, { theme: themeName });
+            return { toolUsed: true, toolName: 'html', toolResult: 'HTML created: ' + result.filename, filePath: result.filepath, fileName: result.filename, cleanResponse };
+          } catch (err) { toolResult = 'HTML failed: ' + err.message; }
+          break;
+        }
+        case 'cron_add': {
+          try {
+            if (!this._engine?.cron) { toolResult = 'Cron not available'; break; }
+            const parts = toolArg.split('|').map(p => p.trim());
+            const [name, schedule, action, ...dataParts] = parts;
+            const data = dataParts.join('|');
+            const result = this._engine.cron.add(agentId, this._currentContactId, name, schedule, action || 'message', data, this._currentPlatform);
+            toolResult = 'Cron job created! ✅\n📋 ' + result.name + '\n⏰ Schedule: ' + result.schedule + '\n🔜 Next run: ' + result.nextRun;
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'cron_list': {
+          try {
+            if (!this._engine?.cron) { toolResult = 'Cron not available'; break; }
+            const jobs = this._engine.cron.listAll(agentId);
+            if (jobs.length === 0) { toolResult = 'No scheduled jobs'; break; }
+            toolResult = jobs.map(j => 
+              (j.enabled ? '✅' : '⏸️') + ' ' + j.name + ' (' + j.schedule + ')\n   ID: ' + j.id + '\n   Next: ' + (j.next_run || 'N/A')
+            ).join('\n\n');
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'cron_remove': {
+          try {
+            if (!this._engine?.cron) { toolResult = 'Cron not available'; break; }
+            this._engine.cron.remove(toolArg.trim());
+            toolResult = 'Cron job removed ✅';
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
         case 'allow': {
           try {
             const { AllowlistManager } = await import('../features/allowlist-manager.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {
@@ -42,12 +42,14 @@
     "commander": "^14.0.3",
     "croner": "^10.0.1",
     "dotenv": "^17.3.1",
+    "exceljs": "^4.4.0",
     "express": "^5.2.1",
     "file-type": "^21.3.0",
     "grammy": "^1.40.1",
     "linkedom": "^0.18.12",
     "node-edge-tts": "^1.2.10",
     "pdfjs-dist": "^5.4.624",
+    "pdfkit": "^0.17.2",
     "pino": "^10.3.1",
     "pptxgenjs": "^4.0.1",
     "puppeteer-core": "^24.37.5",