@johpaz/hive-sdk 0.0.4 → 0.0.6

package/dist/cron/index.js

@@ -1,25 +1,3245 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../core/src/config/loader.ts
+import * as z from "zod";
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+function loadEnv(hiveDir) {
+  const envPath = path.join(hiveDir, ".env");
+  if (existsSync(envPath)) {
+    try {
+      const text = readFileSync(envPath, "utf8");
+      const lines = text.split(`
+`);
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+          continue;
+        const [key, ...valueParts] = trimmed.split("=");
+        if (key && valueParts.length > 0) {
+          const value = valueParts.join("=").trim().replace(/^['"]|['"]$/g, "");
+          process.env[key.trim()] = value;
+        }
+      }
+    } catch (e) {}
+  }
+}
+function getHiveDir() {
+  if (process.env.HIVE_HOME) {
+    const hiveDir = process.env.HIVE_HOME.startsWith("~") ? path.join(process.env.HOME || "", process.env.HIVE_HOME.slice(1)) : process.env.HIVE_HOME;
+    loadEnv(hiveDir);
+    return hiveDir;
+  }
+  if (process.env.HIVE_DEV === "1" || process.env.HIVE_DEV === "true") {
+    const localDir = path.join(process.cwd(), ".hive-dev");
+    loadEnv(localDir);
+    return localDir;
+  }
+  const defaultDir = path.join(process.env.HOME || "", ".hive");
+  loadEnv(defaultDir);
+  return defaultDir;
+}
+function buildDefaultConfig() {
+  const hiveDir = getHiveDir();
+  return {
+    gateway: {
+      host: process.env.HIVE_HOST || "127.0.0.1",
+      port: parseInt(process.env.HIVE_PORT || "18790", 10),
+      pidFile: path.join(hiveDir, "gateway.pid"),
+      authToken: process.env.HIVE_AUTH_TOKEN || undefined,
+      tools: {
+        allow: ["*"],
+        deny: []
+      }
+    },
+    logging: {
+      level: process.env.HIVE_LOG_LEVEL || "info",
+      dir: path.join(hiveDir, "logs"),
+      maxSizeMB: 10,
+      maxFiles: 5,
+      redactSensitive: true,
+      console: true
+    },
+    agent: {
+      defaultAgentId: "main",
+      baseDir: path.join(hiveDir, "agents"),
+      context: {
+        maxTokens: 0,
+        compactionThreshold: 0.8,
+        minMessagesAfterCompaction: 4,
+        maxCompactionRetries: 3
+      }
+    },
+    models: {
+      defaultProvider: "openai",
+      defaults: {
+        openai: "gpt-4o",
+        anthropic: "claude-sonnet-4-20250514",
+        ollama: "llama3.2",
+        openrouter: "anthropic/claude-sonnet-4"
+      },
+      providers: {}
+    },
+    sessions: {
+      dir: path.join(hiveDir, "sessions"),
+      pruneAfterHours: 24,
+      maxTranscriptSizeMB: 50
+    },
+    agents: {
+      list: [
+        {
+          id: "main",
+          default: true,
+          workspace: path.join(hiveDir, "agents", "main", "workspace"),
+          description: "Default personal assistant"
+        }
+      ]
+    },
+    bindings: [],
+    channels: {
+      webchat: { enabled: true }
+    },
+    tools: {
+      allow: ["*"],
+      deny: [],
+      exec: {
+        enabled: true,
+        allowlist: [],
+        denylist: ["rm -rf /", "sudo", "chmod 777", "> /dev/", "mkfs"],
+        timeoutSeconds: 30,
+        workDir: path.join(process.env.HOME || "", "exec")
+      },
+      web: {
+        allowlist: [],
+        denylist: ["file://", "ftp://"],
+        timeoutSeconds: 30
+      },
+      browser: {
+        enabled: true,
+        cdpUrl: "ws://127.0.0.1:9222",
+        headless: true,
+        timeoutMs: 30000
+      },
+      canvas: {
+        enabled: true,
+        port: 18793
+      },
+      sandbox: {
+        dm: { allow: ["*"], deny: [] },
+        group: { allow: ["*"], deny: [] }
+      }
+    },
+    skills: {
+      allowBundled: [],
+      managedDir: path.join(hiveDir, "skills"),
+      extraDirs: [],
+      hotReload: true,
+      maxSkillSizeKB: 100
+    },
+    mcp: {
+      enabled: true,
+      servers: {},
+      healthCheck: {
+        enabled: true,
+        intervalSeconds: 60
+      }
+    },
+    memory: {
+      dbPath: path.join(hiveDir, "memory.db"),
+      notesDir: path.join(hiveDir, "agents", "main", "workspace", "memory"),
+      episodic: {
+        enabled: false,
+        provider: "openai",
+        maxEpisodesPerSession: 100
+      }
+    },
+    cron: {
+      enabled: true,
+      dbPath: path.join(hiveDir, "cron.db"),
+      maxConcurrentJobs: 5,
+      timezone: "UTC"
+    },
+    retry: {
+      maxAttempts: 3,
+      initialDelayMs: 1000,
+      backoffMultiplier: 2,
+      maxDelayMs: 30000
+    },
+    security: {
+      maxMessageLength: {
+        telegram: 4096,
+        discord: 2000,
+        slack: 40000,
+        webchat: 1e5,
+        whatsapp: 65536
+      },
+      skillScanning: true,
+      warnOnInsecureConfig: true
+    },
+    hooks: {
+      scripts: {}
+    },
+    captcha: {
+      enabled: false,
+      autoSolve: true,
+      visionProvider: "gemini",
+      visionModel: "gemini-2.0-flash-exp",
+      maxAttempts: 3,
+      maxRounds: 5,
+      enabledSites: []
+    }
+  };
+}
+function loadConfig() {
+  return buildDefaultConfig();
+}
+var LogLevelSchema, DMPolicySchema, TransportSchema, ProviderConfigSchema, ToolRestrictionsSchema, ExecConfigSchema, WebConfigSchema, BrowserConfigSchema, CanvasConfigSchema, SandboxConfigSchema, ToolsConfigSchema, ContextConfigSchema, AgentEntrySchema, AccountConfigSchema, ChannelConfigSchema, PeerMatchSchema, BindingMatchSchema, BindingSchema, MCPServerConfigSchema, MCPConfigSchema, EpisodicMemoryConfigSchema, MemoryConfigSchema, CronConfigSchema, RetryConfigSchema, HooksConfigSchema, LoggingConfigSchema, GatewayConfigSchema, ModelsConfigSchema, SessionsConfigSchema, SkillsConfigSchema, SecurityConfigSchema, CaptchaConfigSchema, UserConfigSchema, ConfigSchema;
+var init_loader = __esm(() => {
+  LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+  DMPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+  TransportSchema = z.enum(["stdio", "sse", "websocket"]);
+  ProviderConfigSchema = z.object({
+    apiKey: z.string().optional(),
+    baseUrl: z.string().optional(),
+    rateLimit: z.number().optional(),
+    retries: z.number().optional(),
+    retryDelayMs: z.number().optional()
+  });
+  ToolRestrictionsSchema = z.object({
+    allow: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional()
+  });
+  ExecConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    allowlist: z.array(z.string()).optional(),
+    denylist: z.array(z.string()).optional(),
+    timeoutSeconds: z.number().optional(),
+    workDir: z.string().optional()
+  });
+  WebConfigSchema = z.object({
+    allowlist: z.array(z.string()).optional(),
+    denylist: z.array(z.string()).optional(),
+    timeoutSeconds: z.number().optional()
+  });
+  BrowserConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    cdpUrl: z.string().optional(),
+    headless: z.boolean().optional(),
+    timeoutMs: z.number().optional()
+  });
+  CanvasConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    port: z.number().optional()
+  });
+  SandboxConfigSchema = z.object({
+    dm: ToolRestrictionsSchema.optional(),
+    group: ToolRestrictionsSchema.optional()
+  });
+  ToolsConfigSchema = z.object({
+    allow: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional(),
+    exec: ExecConfigSchema.optional(),
+    web: WebConfigSchema.optional(),
+    browser: BrowserConfigSchema.optional(),
+    canvas: CanvasConfigSchema.optional(),
+    sandbox: SandboxConfigSchema.optional()
+  });
+  ContextConfigSchema = z.object({
+    maxTokens: z.number().optional(),
+    compactionThreshold: z.number().optional(),
+    minMessagesAfterCompaction: z.number().optional(),
+    maxCompactionRetries: z.number().optional()
+  });
+  AgentEntrySchema = z.object({
+    id: z.string(),
+    default: z.boolean().optional(),
+    workspace: z.string(),
+    description: z.string().optional()
+  });
+  AccountConfigSchema = z.object({
+    botToken: z.string().optional(),
+    applicationId: z.string().optional(),
+    appToken: z.string().optional(),
+    signingSecret: z.string().optional(),
+    dmPolicy: DMPolicySchema.optional(),
+    allowFrom: z.array(z.string()).optional()
+  });
+  ChannelConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    accounts: z.record(z.string(), AccountConfigSchema).optional(),
+    dmPolicy: DMPolicySchema.optional(),
+    allowFrom: z.array(z.string()).optional(),
+    groups: z.boolean().optional(),
+    guilds: z.record(z.string(), z.unknown()).optional(),
+    experimental: z.boolean().optional()
+  });
+  PeerMatchSchema = z.object({
+    kind: z.enum(["direct", "group"]).optional(),
+    id: z.string().optional()
+  });
+  BindingMatchSchema = z.object({
+    channel: z.string().optional(),
+    accountId: z.string().optional(),
+    peer: PeerMatchSchema.optional(),
+    guildId: z.string().optional(),
+    teamId: z.string().optional(),
+    roles: z.array(z.string()).optional()
+  });
+  BindingSchema = z.object({
+    agentId: z.string(),
+    match: BindingMatchSchema
+  });
+  MCPServerConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    transport: TransportSchema,
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    url: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    reconnect: z.object({
+      enabled: z.boolean().optional(),
+      maxRetries: z.number().optional(),
+      delayMs: z.number().optional(),
+      backoffMultiplier: z.number().optional()
+    }).optional()
+  });
+  MCPConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    servers: z.record(z.string(), MCPServerConfigSchema).optional(),
+    healthCheck: z.object({
+      enabled: z.boolean().optional(),
+      intervalSeconds: z.number().optional()
+    }).optional()
+  });
+  EpisodicMemoryConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    provider: z.enum(["openai", "local"]).optional(),
+    maxEpisodesPerSession: z.number().optional()
+  });
+  MemoryConfigSchema = z.object({
+    dbPath: z.string().optional(),
+    notesDir: z.string().optional(),
+    episodic: EpisodicMemoryConfigSchema.optional()
+  });
+  CronConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    dbPath: z.string().optional(),
+    maxConcurrentJobs: z.number().optional(),
+    timezone: z.string().optional()
+  });
+  RetryConfigSchema = z.object({
+    maxAttempts: z.number().optional(),
+    initialDelayMs: z.number().optional(),
+    backoffMultiplier: z.number().optional(),
+    maxDelayMs: z.number().optional()
+  });
+  HooksConfigSchema = z.object({
+    scripts: z.object({
+      before_model_resolve: z.string().optional(),
+      before_prompt_build: z.string().optional(),
+      before_tool_call: z.string().optional(),
+      after_tool_call: z.string().optional(),
+      tool_result_persist: z.string().optional(),
+      before_compaction: z.string().optional(),
+      after_compaction: z.string().optional(),
+      message_received: z.string().optional(),
+      message_sending: z.string().optional(),
+      message_sent: z.string().optional(),
+      session_start: z.string().optional(),
+      session_end: z.string().optional(),
+      gateway_start: z.string().optional(),
+      gateway_stop: z.string().optional()
+    }).optional()
+  });
+  LoggingConfigSchema = z.object({
+    level: LogLevelSchema.optional(),
+    dir: z.string().optional(),
+    maxSizeMB: z.number().optional(),
+    maxFiles: z.number().optional(),
+    redactSensitive: z.boolean().optional(),
+    console: z.boolean().optional()
+  });
+  GatewayConfigSchema = z.object({
+    host: z.string().optional(),
+    port: z.number().optional(),
+    authToken: z.string().optional(),
+    pidFile: z.string().optional(),
+    tools: ToolRestrictionsSchema.optional()
+  });
+  ModelsConfigSchema = z.object({
+    defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek"]).optional(),
+    defaults: z.record(z.string(), z.string()).optional(),
+    providers: z.record(z.string(), ProviderConfigSchema).optional()
+  });
+  SessionsConfigSchema = z.object({
+    dir: z.string().optional(),
+    pruneAfterHours: z.number().optional(),
+    maxTranscriptSizeMB: z.number().optional()
+  });
+  SkillsConfigSchema = z.object({
+    allowBundled: z.array(z.string()).optional(),
+    managedDir: z.string().optional(),
+    extraDirs: z.array(z.string()).optional(),
+    hotReload: z.boolean().optional(),
+    maxSkillSizeKB: z.number().optional()
+  });
+  SecurityConfigSchema = z.object({
+    maxMessageLength: z.record(z.string(), z.number()).optional(),
+    skillScanning: z.boolean().optional(),
+    warnOnInsecureConfig: z.boolean().optional(),
+    allowedUsers: z.array(z.string()).optional()
+  });
+  CaptchaConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    autoSolve: z.boolean().optional(),
+    visionProvider: z.enum(["gemini", "openai", "anthropic"]).optional(),
+    visionModel: z.string().optional(),
+    maxAttempts: z.number().optional(),
+    maxRounds: z.number().optional(),
+    apiKey: z.string().optional(),
+    enabledSites: z.array(z.string()).optional()
+  });
+  UserConfigSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    channels: z.record(z.string(), z.string()).optional()
+  });
+  ConfigSchema = z.object({
+    gateway: GatewayConfigSchema.optional(),
+    logging: LoggingConfigSchema.optional(),
+    user: UserConfigSchema.optional(),
+    agent: z.object({
+      defaultAgentId: z.string().optional(),
+      baseDir: z.string().optional(),
+      context: ContextConfigSchema.optional()
+    }).optional(),
+    models: ModelsConfigSchema.optional(),
+    sessions: SessionsConfigSchema.optional(),
+    agents: z.object({
+      list: z.array(AgentEntrySchema).optional()
+    }).optional(),
+    bindings: z.array(BindingSchema).optional(),
+    channels: z.record(z.string(), ChannelConfigSchema).optional(),
+    tools: ToolsConfigSchema.optional(),
+    skills: SkillsConfigSchema.optional(),
+    mcp: MCPConfigSchema.optional(),
+    memory: MemoryConfigSchema.optional(),
+    cron: CronConfigSchema.optional(),
+    retry: RetryConfigSchema.optional(),
+    security: SecurityConfigSchema.optional(),
+    hooks: HooksConfigSchema.optional(),
+    captcha: CaptchaConfigSchema.optional()
+  });
+});
+
+// ../core/src/utils/logger.ts
+import { mkdirSync as mkdirSync2, unlinkSync, renameSync, existsSync as existsSync2 } from "fs";
+import * as path2 from "path";
+function emitLogEntry(entry) {
+  for (const cb of _logListeners) {
+    try {
+      cb(entry);
+    } catch {}
+  }
+}
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return path2.join(process.env.HOME || "", p.slice(1));
+  }
+  return p;
+}
+function redact(obj, seen = new WeakSet) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (seen.has(obj)) {
+    return "[Circular]";
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => redact(item, seen));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const isSensitive = SENSITIVE_PATTERNS.some((p) => p.test(key));
+    if (isSensitive) {
+      result[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = redact(value, seen);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function formatTimestamp() {
+  return new Date().toISOString();
+}
+function formatMessage(level, message, meta, correlationId) {
+  const timestamp = formatTimestamp();
+  const corrStr = correlationId ? ` [${correlationId.slice(0, 8)}]` : "";
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+  return `[${timestamp}]${corrStr} [${level.toUpperCase()}] ${message}${metaStr}`;
+}
+
+class Logger {
+  config;
+  logFile = null;
+  currentSize = 0;
+  correlationContext = {};
+  constructor(config = {}) {
+    this.config = {
+      level: config.level ?? "info",
+      dir: config.dir ?? path2.join(getHiveDir(), "logs"),
+      maxSizeMB: config.maxSizeMB ?? 10,
+      maxFiles: config.maxFiles ?? 5,
+      redactSensitive: config.redactSensitive ?? true,
+      console: config.console ?? true
+    };
+  }
+  setCorrelationContext(context) {
+    this.correlationContext = { ...this.correlationContext, ...context };
+  }
+  clearCorrelationContext() {
+    this.correlationContext = {};
+  }
+  getCorrelationId() {
+    return this.correlationContext.correlationId;
+  }
+  withCorrelationId(id) {
+    this.correlationContext.correlationId = id;
+    return this;
+  }
+  initLogFile() {
+    const logDir = expandPath(this.config.dir);
+    try {
+      if (!existsSync2(logDir)) {
+        mkdirSync2(logDir, { recursive: true });
+      }
+      this.logFile = path2.join(logDir, `hive-${new Date().toISOString().split("T")[0]}.log`);
+      const file = Bun.file(this.logFile);
+      this.currentSize = file.size ?? 0;
+    } catch {
+      this.logFile = null;
+    }
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+  }
+  writeToConsole(level, message, meta) {
+    if (!this.config.console)
+      return;
+    const color = COLORS[level];
+    const mergedMeta = this.mergeMeta(meta);
+    const displayMeta = this.config.redactSensitive && mergedMeta ? redact(mergedMeta) : mergedMeta;
+    const metaStr = displayMeta && Object.keys(displayMeta).length > 0 ? ` ${JSON.stringify(displayMeta)}` : "";
+    const prefix = `${COLORS.dim}${formatTimestamp()}${COLORS.reset}`;
+    const corrStr = this.correlationContext.correlationId ? ` ${COLORS.dim}[${this.correlationContext.correlationId.slice(0, 8)}]${COLORS.reset}` : "";
+    const levelStr = `${color}${COLORS.bright}[${level.toUpperCase().padEnd(5)}]${COLORS.reset}`;
+    console.log(`${prefix}${corrStr} ${levelStr} ${message}${metaStr}`);
+  }
+  mergeMeta(meta) {
+    if (!meta && Object.keys(this.correlationContext).length === 0)
+      return;
+    const contextWithoutCorrId = { ...this.correlationContext };
+    delete contextWithoutCorrId.correlationId;
+    if (!meta)
+      return contextWithoutCorrId;
+    if (typeof meta !== "object")
+      return meta;
+    return { ...contextWithoutCorrId, ...meta };
+  }
+  writeToFile(message) {
+    if (!this.logFile) {
+      this.initLogFile();
+    }
+    if (!this.logFile)
+      return;
+    try {
+      const line = message + `
+`;
+      const bytes = Buffer.byteLength(line);
+      if (this.currentSize + bytes > this.config.maxSizeMB * 1024 * 1024) {
+        this.rotateLogs();
+      }
+      const encoder = new TextEncoder;
+      const data = encoder.encode(line);
+      Bun.write(this.logFile, data).catch(() => {});
+      this.currentSize += bytes;
+    } catch {}
+  }
+  rotateLogs() {
+    if (!this.logFile)
+      return;
+    const logDir = path2.dirname(this.logFile);
+    const baseName = path2.basename(this.logFile, ".log");
+    for (let i = this.config.maxFiles - 1;i >= 1; i--) {
+      const oldFile = path2.join(logDir, `${baseName}.${i}.log`);
+      const newFile = path2.join(logDir, `${baseName}.${i + 1}.log`);
+      try {
+        if (existsSync2(oldFile)) {
+          if (i === this.config.maxFiles - 1) {
+            unlinkSync(oldFile);
+          } else {
+            renameSync(oldFile, newFile);
+          }
+        }
+      } catch {}
+    }
+    try {
+      renameSync(this.logFile, path2.join(logDir, `${baseName}.1.log`));
+      this.currentSize = 0;
+    } catch {}
+  }
+  debug(message, meta) {
+    if (!this.shouldLog("debug"))
+      return;
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("debug", message, mergedMeta, this.correlationContext.correlationId);
+    this.writeToConsole("debug", message, meta);
+    this.writeToFile(formatted);
+    emitLogEntry({ timestamp: formatTimestamp(), level: "debug", source: "core", message, meta: mergedMeta });
+  }
+  info(message, meta) {
+    if (!this.shouldLog("info"))
+      return;
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("info", message, mergedMeta, this.correlationContext.correlationId);
+    this.writeToConsole("info", message, meta);
+    this.writeToFile(formatted);
+    emitLogEntry({ timestamp: formatTimestamp(), level: "info", source: "core", message, meta: mergedMeta });
+  }
+  warn(message, meta) {
+    if (!this.shouldLog("warn"))
+      return;
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("warn", message, mergedMeta, this.correlationContext.correlationId);
+    this.writeToConsole("warn", message, meta);
+    this.writeToFile(formatted);
+    emitLogEntry({ timestamp: formatTimestamp(), level: "warn", source: "core", message, meta: mergedMeta });
+  }
+  error(message, meta) {
+    if (!this.shouldLog("error"))
+      return;
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("error", message, mergedMeta, this.correlationContext.correlationId);
+    this.writeToConsole("error", message, meta);
+    this.writeToFile(formatted);
+    emitLogEntry({ timestamp: formatTimestamp(), level: "error", source: "core", message, meta: mergedMeta });
+  }
+  child(context) {
+    return new ChildLogger(this, context, this.correlationContext);
+  }
+  setLevel(level) {
+    this.config.level = level;
+  }
+}
+
+class ChildLogger {
+  parent;
+  context;
+  correlationContext;
+  constructor(parent, context, correlationContext = {}) {
+    this.parent = parent;
+    this.context = context;
+    this.correlationContext = correlationContext;
+  }
+  prefix(message) {
+    return `[${this.context}] ${message}`;
+  }
+  withCorrelationId(id) {
+    this.correlationContext.correlationId = id;
+    return this;
+  }
+  setContext(context) {
+    this.correlationContext = { ...this.correlationContext, ...context };
+  }
+  debug(message, meta) {
+    this.parent.debug(this.prefix(message), this.mergeMeta(meta));
+  }
+  info(message, meta) {
+    this.parent.info(this.prefix(message), this.mergeMeta(meta));
+  }
+  warn(message, meta) {
+    this.parent.warn(this.prefix(message), this.mergeMeta(meta));
+  }
+  error(message, meta) {
+    this.parent.error(this.prefix(message), this.mergeMeta(meta));
+  }
+  child(subContext) {
+    return new ChildLogger(this.parent, `${this.context}:${subContext}`, this.correlationContext);
+  }
+  mergeMeta(meta) {
+    if (!meta && Object.keys(this.correlationContext).length === 0)
+      return;
+    if (!meta)
+      return { ...this.correlationContext };
+    if (typeof meta !== "object")
+      return meta;
+    return { ...this.correlationContext, ...meta };
+  }
+}
+function getLogger() {
+  if (!_logger) {
+    const config = loadConfig();
+    _logger = new Logger({ level: config.logging?.level });
+  }
+  return _logger;
+}
+var _logListeners, LOG_LEVELS, SENSITIVE_PATTERNS, COLORS, _logger = null, logger;
+var init_logger = __esm(() => {
+  init_loader();
+  _logListeners = new Set;
+  LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  SENSITIVE_PATTERNS = [
+    /api[_-]?key/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /auth/i
+  ];
+  COLORS = {
+    debug: "\x1B[36m",
+    info: "\x1B[32m",
+    warn: "\x1B[33m",
+    error: "\x1B[31m",
+    reset: "\x1B[0m",
+    dim: "\x1B[2m",
+    bright: "\x1B[1m"
+  };
+  logger = {
+    child: (opts) => getLogger().child(opts),
+    debug: (msg, meta) => getLogger().debug(msg, meta),
+    info: (msg, meta) => getLogger().info(msg, meta),
+    warn: (msg, meta) => getLogger().warn(msg, meta),
+    error: (msg, meta) => getLogger().error(msg, meta),
+    setCorrelationContext: (ctx) => getLogger().setCorrelationContext(ctx),
+    clearCorrelationContext: () => getLogger().clearCorrelationContext(),
+    getCorrelationId: () => getLogger().getCorrelationId(),
+    withCorrelationId: (id) => getLogger().withCorrelationId(id),
+    setLevel: (level) => getLogger().setLevel(level),
+    setHandler: (handler) => {}
+  };
+});
+
+// ../core/src/storage/schema.ts
+var SCHEMA = `
+  PRAGMA journal_mode = WAL;
+  PRAGMA foreign_keys = ON;
+
+  -- ENCRYPTION KEY (stored separately, used for encrypting sensitive data)
+  -- The encryption key is derived from HIVE_MASTER_KEY env var or generated on first run
+  
+  -- CONFIGURATION (all linked to user)
+
+  CREATE TABLE IF NOT EXISTS users (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    name            TEXT,
+    language        TEXT,
+    timezone        TEXT,
+    occupation      TEXT,
+    notes           TEXT,
+    master_key_hash TEXT,
+    email           TEXT UNIQUE,
+    password_hash   TEXT,
+    preferred_cron_channel TEXT NOT NULL DEFAULT 'auto',
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- Providers: linked to user (API key encrypted)
+  -- Solo la empresa (OpenAI, Groq, ElevenLabs, etc.)
+  -- La API key es del provider, no del modelo
+  -- category: 'llm', 'stt', 'tts' (default: llm)
+  CREATE TABLE IF NOT EXISTS providers (
+    id              TEXT PRIMARY KEY,
+    name            TEXT NOT NULL UNIQUE,
+    api_key_encrypted TEXT,
+    api_key_iv      TEXT,
+    headers_encrypted TEXT,
+    headers_iv      TEXT,
+    base_url        TEXT,
+    category        TEXT NOT NULL DEFAULT 'llm',
+    num_ctx         INTEGER,
+    num_gpu         INTEGER DEFAULT -1,
+    enabled         INTEGER NOT NULL DEFAULT 1,
+    active          INTEGER NOT NULL DEFAULT 0,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- Models: linked to provider
+  -- model_type: 'llm', 'stt', 'tts', 'vision', 'embedding'
+  -- stt models: whisper-1, whisper-large-v3
+  -- tts models: tts-1, gpt-4o-mini-tts, eleven_multilingual_v2
+  CREATE TABLE IF NOT EXISTS models (
+    id              TEXT PRIMARY KEY,
+    provider_id     TEXT REFERENCES providers(id) ON DELETE CASCADE,
+    name            TEXT NOT NULL,
+    model_type      TEXT NOT NULL DEFAULT 'llm',
+    context_window  INTEGER NOT NULL DEFAULT 20000,
+    capabilities    TEXT,
+    enabled         INTEGER NOT NULL DEFAULT 1,
+    active          INTEGER NOT NULL DEFAULT 0
+  );
+
+  -- Agents: linked to user + provider/model
+  -- role: 'coordinator' | 'worker'
+  -- system_prompt: explicit prompt (description is a human-readable summary)
+  -- tools_json: JSON array of tool IDs this agent can use (NULL = all)
+  -- skills_json: JSON array of skill IDs this agent can use (NULL = all)
+  -- parent_id: agent that created this one (NULL for coordinator)
+  -- max_iterations: loop limit per invocation
+  CREATE TABLE IF NOT EXISTS agents (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    user_id         TEXT REFERENCES users(id) ON DELETE CASCADE,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    system_prompt   TEXT,
+    tone            TEXT,
+    role            TEXT NOT NULL DEFAULT 'coordinator' CHECK(role IN ('coordinator', 'worker')),
+    status          TEXT NOT NULL DEFAULT 'idle',
+    enabled         INTEGER NOT NULL DEFAULT 1,
+    provider_id     TEXT REFERENCES providers(id),
+    model_id        TEXT REFERENCES models(id),
+    tools_json      TEXT,
+    skills_json     TEXT,
+    parent_id       TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    max_iterations  INTEGER NOT NULL DEFAULT 10,
+    headers_encrypted TEXT,
+    headers_iv      TEXT,
+    workspace       TEXT,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- Channels: linked to user (or global if user_id is NULL)
+  -- voice_enabled: enables speech-to-text for incoming audio
+  -- tts_enabled: enables text-to-speech for outgoing responses
+  -- stt_provider: which STT provider to use (groq-whisper, openai-whisper)
+  -- tts_provider: which TTS provider to use (elevenlabs, openai-tts)
+  -- tts_voice_id: specific voice ID for TTS (e.g., ElevenLabs voice ID)
+  -- step_delivery_mode: how to send intermediate steps to user:
+  --   "new_message" = send new message for each step (default)
+  --   "edit" = edit same message (Telegram/Discord only)
+  --   "thread" = use threading (Slack only)
+  CREATE TABLE IF NOT EXISTS channels (
+    id          TEXT PRIMARY KEY,
+    user_id     TEXT REFERENCES users(id) ON DELETE CASCADE,
+    type        TEXT NOT NULL,
+    config_encrypted TEXT,
+    config_iv   TEXT,
+    enabled     INTEGER NOT NULL DEFAULT 1,
+    active      INTEGER NOT NULL DEFAULT 0,
+    status      TEXT NOT NULL DEFAULT 'disconnected',
+    last_active INTEGER,
+    voice_enabled INTEGER NOT NULL DEFAULT 0,
+    tts_enabled INTEGER NOT NULL DEFAULT 0,
+    stt_provider TEXT,
+    tts_provider TEXT,
+    tts_voice_id TEXT,
+    step_delivery_mode TEXT DEFAULT 'new_messages'
+  );
+
+  -- MCP Servers: linked to user (or global if user_id is NULL)
+  CREATE TABLE IF NOT EXISTS mcp_servers (
+    id          TEXT PRIMARY KEY,
+    name        TEXT NOT NULL,
+    transport   TEXT NOT NULL,
+    command     TEXT,
+    args        TEXT,
+    env_encrypted TEXT,
+    env_iv      TEXT,
+    headers_encrypted TEXT,
+    headers_iv  TEXT,
+    url         TEXT,
+    enabled     INTEGER NOT NULL DEFAULT 1,
+    active      INTEGER NOT NULL DEFAULT 0,
+    builtin     INTEGER NOT NULL DEFAULT 0,
+    status      TEXT NOT NULL DEFAULT 'disconnected',
+    tools_count INTEGER DEFAULT 0
+  );
+
+  -- MCP Servers: external tool providers (stdio, SSE, etc.)
+  -- MCP tools are loaded at runtime from connected servers, not stored in DB
+  CREATE TABLE IF NOT EXISTS mcp_servers (
+    id          TEXT PRIMARY KEY,
+    name        TEXT NOT NULL,
+    transport   TEXT NOT NULL,
+    command     TEXT,
+    args        TEXT,
+    env_encrypted TEXT,
+    env_iv      TEXT,
+    headers_encrypted TEXT,
+    headers_iv  TEXT,
+    url         TEXT,
+    enabled     INTEGER NOT NULL DEFAULT 1,
+    active      INTEGER NOT NULL DEFAULT 0,
+    builtin     INTEGER NOT NULL DEFAULT 0,
+    status      TEXT NOT NULL DEFAULT 'disconnected',
+    tools_count INTEGER DEFAULT 0
+  );
+
+  -- Note: MCP tools are NOT stored in DB. They are loaded from MCP servers at runtime
+  -- and made available directly via context-compiler (Direct Connection architecture)
+
+  -- Skills: can be global (system) or user-specific
+  -- Simplified schema with body field for markdown content
+  CREATE TABLE IF NOT EXISTS skills (
+    id          TEXT PRIMARY KEY,        -- 'web_research'
+    name        TEXT NOT NULL,           -- 'Web Research'
+    category    TEXT NOT NULL,           -- 'web'
+    tools       TEXT NOT NULL,           -- 'web_search,web_fetch'
+    triggers    TEXT NOT NULL,           -- 'investiga,busca,research'
+    body        TEXT NOT NULL,           -- Markdown completo
+    version     INTEGER DEFAULT 1,
+    active      INTEGER DEFAULT 1,       -- 1=activo, 0=desactivado
+    created_at  TEXT DEFAULT (datetime('now')),
+    updated_at  TEXT DEFAULT (datetime('now'))
+  );
+
+  -- \xCDndices para filtros directos
+  CREATE INDEX IF NOT EXISTS idx_skills_category ON skills(category);
+  CREATE INDEX IF NOT EXISTS idx_skills_active ON skills(active);
+
+  -- Tools: global (bundled), not user-specific
+  -- category: 'bundled', 'workspace', 'project', 'builtin', 'voice'
+  CREATE TABLE IF NOT EXISTS tools (
+    id          TEXT PRIMARY KEY,
+    name        TEXT NOT NULL UNIQUE,
+    description TEXT,
+    category    TEXT,
+    enabled     INTEGER NOT NULL DEFAULT 1,
+    active      INTEGER NOT NULL DEFAULT 1,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at  INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- Ethics: global templates (user selects one)
+  CREATE TABLE IF NOT EXISTS ethics (
+    id              TEXT PRIMARY KEY,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    content         TEXT NOT NULL,
+    is_default      INTEGER NOT NULL DEFAULT 0,
+    enabled         INTEGER NOT NULL DEFAULT 1,
+    active          INTEGER NOT NULL DEFAULT 0
+  );
+
+  -- Code Bridge: external CLI tools configuration (global)
+  CREATE TABLE IF NOT EXISTS code_bridge (
+    id              TEXT PRIMARY KEY,
+    user_id     TEXT REFERENCES users(id) ON DELETE CASCADE,
+    name            TEXT NOT NULL UNIQUE,
+    cli_command     TEXT NOT NULL,
+    enabled         INTEGER NOT NULL DEFAULT 0,
+    active          INTEGER NOT NULL DEFAULT 0,
+    port            INTEGER DEFAULT 18791,
+    config          TEXT
+  );
+
+  -- Code Bridge Config: key-value store for configuration (voice_wake_word, etc.)
+  CREATE TABLE IF NOT EXISTS code_bridge_config (
+    id              TEXT PRIMARY KEY,
+    user_id         TEXT REFERENCES users(id) ON DELETE CASCADE,
+    key             TEXT NOT NULL,
+    value           TEXT,
+    UNIQUE(user_id, key)
+  );
+
+  -- USER IDENTITIES (channel + user mapping)
+
+  CREATE TABLE IF NOT EXISTS user_identities (
+    user_id         TEXT NOT NULL REFERENCES users(id),
+    channel         TEXT NOT NULL,
+    channel_user_id TEXT NOT NULL,
+    linked_at       INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (user_id, channel)
+  );
+
+  -- USER CHANNELS (user-specific channel configurations)
+  -- Stores per-user channel account configurations (Telegram bot, Discord bot, etc.)
+  -- config: JSON object with channel-specific settings (bot token, webhook URL, etc.)
+  -- active: 1 = enabled and running, 0 = disabled
+  CREATE TABLE IF NOT EXISTS user_channels (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id     TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    channel     TEXT NOT NULL,
+    account_id  TEXT NOT NULL,
+    config      TEXT,
+    active      INTEGER NOT NULL DEFAULT 1,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    UNIQUE(user_id, channel, account_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_user_channels_user ON user_channels(user_id);
+  CREATE INDEX IF NOT EXISTS idx_user_channels_channel ON user_channels(channel);
+
+  -- ONBOARDING PROGRESS
+
+  CREATE TABLE IF NOT EXISTS onboarding_progress (
+    id        TEXT PRIMARY KEY,
+    user_id   TEXT REFERENCES users(id) ON DELETE CASCADE,
+    step      TEXT NOT NULL,
+    data      TEXT,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- USAGE TRACKING (tokens, costs)
+  CREATE TABLE IF NOT EXISTS usage_records (
+    id            TEXT PRIMARY KEY,
+    provider      TEXT NOT NULL,
+    model         TEXT NOT NULL,
+    input_tokens  INTEGER NOT NULL DEFAULT 0,
+    output_tokens INTEGER NOT NULL DEFAULT 0,
+    cost_usd      REAL NOT NULL DEFAULT 0,
+    latency_ms    INTEGER,
+    
+    -- TOON Savings
+    toon_saved_tokens     INTEGER NOT NULL DEFAULT 0,
+    toon_saved_cost       REAL NOT NULL DEFAULT 0,
+    
+    -- TOON Metrics (complete compression analysis)
+    toon_json_bytes       INTEGER NOT NULL DEFAULT 0,
+    toon_toon_bytes       INTEGER NOT NULL DEFAULT 0,
+    toon_saved_bytes      INTEGER NOT NULL DEFAULT 0,
+    toon_saved_percent    REAL NOT NULL DEFAULT 0,
+    toon_json_tokens      INTEGER NOT NULL DEFAULT 0,
+    toon_toon_tokens      INTEGER NOT NULL DEFAULT 0,
+    toon_saved_tokens_pct REAL NOT NULL DEFAULT 0,
+    
+    created_at     INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- CRON JOBS: scheduled tasks with notification channel
+  -- notify_channel_id: which channel to send notifications to when task runs
+  -- max_runs: NULL = unlimited; auto-disables when run_count reaches max_runs
+  -- expires_at: NULL = never expires; auto-disables after this UTC timestamp
+  CREATE TABLE IF NOT EXISTS cron_jobs (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    user_id         TEXT REFERENCES users(id) ON DELETE CASCADE,
+    project_id      TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    name            TEXT NOT NULL,
+    cron_expression TEXT NOT NULL,
+    task_type       TEXT NOT NULL DEFAULT 'message',
+    task_config     TEXT,
+    notify_channel_id TEXT,
+    enabled         INTEGER NOT NULL DEFAULT 1,
+    max_runs        INTEGER,
+    run_count       INTEGER NOT NULL DEFAULT 0,
+    expires_at      INTEGER,
+    last_run        INTEGER,
+    next_run        INTEGER,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- SCHEDULER: New Croner-based scheduled tasks (replaces cron_jobs)
+  -- task_type: 'recurring' (uses cron_expression) or 'one_shot' (uses fire_at)
+  -- cron_expression: stored in user's local time, not UTC
+  -- fire_at: ISO 8601 format in user's local time (e.g., "2026-04-01T09:00:00")
+  -- timezone: IANA timezone string (e.g., "America/Bogota") inherited from users.timezone
+  -- protect: overrun protection (1 = enabled, 0 = disabled)
+  -- payload: JSON string with at least { prompt: string } or { message: string }
+  -- CHECK constraint: recurring requires cron_expression, one_shot requires fire_at
+  CREATE TABLE IF NOT EXISTS scheduled_tasks (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+    name            TEXT NOT NULL,
+    description     TEXT DEFAULT '',
+    task_type       TEXT NOT NULL CHECK(task_type IN ('recurring', 'one_shot')),
+    cron_expression TEXT,
+    fire_at         TEXT,
+    timezone        TEXT NOT NULL DEFAULT 'UTC',
+    max_runs        INTEGER,
+    protect         INTEGER NOT NULL DEFAULT 1,
+    interval_sec    INTEGER,
+    agent_id        TEXT,
+    channel         TEXT DEFAULT 'system',
+    payload         TEXT DEFAULT '{}',
+    tool_name       TEXT,
+    status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'failed', 'cancelled')),
+    run_count       INTEGER NOT NULL DEFAULT 0,
+    error_count     INTEGER NOT NULL DEFAULT 0,
+    last_error      TEXT,
+    created_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+    updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+    last_run_at     TEXT,
+    next_run_at     TEXT,
+    completed_at    TEXT,
+    CHECK(
+      (task_type = 'recurring' AND cron_expression IS NOT NULL) OR
+      (task_type = 'one_shot' AND fire_at IS NOT NULL)
+    )
+  );
+
+  -- SCHEDULER: Task execution history
+  -- Stores results of each task execution for debugging and auditing
+  CREATE TABLE IF NOT EXISTS task_runs (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+    task_id         TEXT NOT NULL REFERENCES scheduled_tasks(id) ON DELETE CASCADE,
+    status          TEXT NOT NULL CHECK(status IN ('running', 'success', 'failed', 'timeout')),
+    started_at      TEXT NOT NULL,
+    finished_at     TEXT,
+    duration_ms     INTEGER,
+    error_message   TEXT,
+    payload_snapshot TEXT,
+    agent_response  TEXT
+  );
+
+  -- INDICES for scheduled_tasks
+  CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_status ON scheduled_tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_type ON scheduled_tasks(task_type);
+  CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_next_run ON scheduled_tasks(next_run_at);
+  CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_agent ON scheduled_tasks(agent_id);
+
+  -- INDICES for task_runs
+  CREATE INDEX IF NOT EXISTS idx_task_runs_task ON task_runs(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_runs_started ON task_runs(started_at);
+  CREATE INDEX IF NOT EXISTS idx_task_runs_status ON task_runs(status);
+
+  -- TRIGGER: Update updated_at on scheduled_tasks UPDATE
+  CREATE TRIGGER IF NOT EXISTS update_scheduled_tasks_updated_at
+    AFTER UPDATE ON scheduled_tasks
+    BEGIN
+      UPDATE scheduled_tasks SET updated_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') WHERE id = NEW.id;
+    END;
+
+  -- INDICES
+
+  CREATE INDEX IF NOT EXISTS idx_models_provider ON models(provider_id);
+  CREATE INDEX IF NOT EXISTS idx_models_type     ON models(model_type);
+  CREATE INDEX IF NOT EXISTS idx_agents_user    ON agents(user_id);
+  CREATE INDEX IF NOT EXISTS idx_channels_user  ON channels(user_id);
+  CREATE INDEX IF NOT EXISTS idx_channels_type  ON channels(type);
+  CREATE INDEX IF NOT EXISTS idx_ethics        ON ethics(id);
+  CREATE INDEX IF NOT EXISTS idx_code_bridge   ON code_bridge(id);
+  CREATE INDEX IF NOT EXISTS idx_identities_user ON user_identities(user_id);
+  CREATE INDEX IF NOT EXISTS idx_usage_provider_model ON usage_records(provider, model);
+  CREATE INDEX IF NOT EXISTS idx_usage_created_at ON usage_records(created_at);
+  CREATE INDEX IF NOT EXISTS idx_code_bridge_config_user ON code_bridge_config(user_id);
+  CREATE INDEX IF NOT EXISTS idx_cron_jobs_user ON cron_jobs(user_id);
+  CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled ON cron_jobs(enabled);
+  CREATE INDEX IF NOT EXISTS idx_cron_jobs_next_run ON cron_jobs(next_run);
+`, PROJECTS_SCHEMA = `
+  -- PROJECTS: tareas multi-paso con seguimiento de progreso
+  CREATE TABLE IF NOT EXISTS projects (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    user_id         TEXT REFERENCES users(id) ON DELETE CASCADE,
+    agent_id        TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    type            TEXT NOT NULL DEFAULT 'general',
+    task            TEXT,
+    progress        INTEGER NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 100),
+    status          TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','active','paused','done','failed')),
+    context         TEXT,
+    parent_id       TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    started_at      INTEGER,
+    completed_at    INTEGER
+  );
+
+  -- TASKS: subtareas at\xF3micas asociadas a un proyecto, con agente asignado
+  -- depends_on: JSON array of task IDs that must complete before this one
+  -- priority: higher = more urgent
+  -- error: reason for failure if status='failed'
+  CREATE TABLE IF NOT EXISTS tasks (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    agent_id        TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    parent_task_id  INTEGER REFERENCES tasks(id) ON DELETE CASCADE,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    status          TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','in_progress','completed','failed','blocked')),
+    progress        INTEGER NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 100),
+    priority        INTEGER NOT NULL DEFAULT 0,
+    depends_on      TEXT,
+    result          TEXT,
+    error           TEXT,
+    metadata        TEXT,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    completed_at    INTEGER
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_projects_user ON projects(user_id);
+  CREATE INDEX IF NOT EXISTS idx_projects_agent ON projects(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_projects_parent ON projects(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+`, CONTEXT_ENGINE_SCHEMA = `
+  -- CONVERSATIONS: full message history per thread (replaces lg_checkpoints)
+  -- role: 'user' | 'assistant' | 'tool' | 'system'
+  -- tool_calls_json: JSON array of tool calls if the message triggered any
+  -- token_count: estimated tokens for context budget tracking
+  CREATE TABLE IF NOT EXISTS conversations (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    thread_id       TEXT NOT NULL,
+    channel         TEXT NOT NULL DEFAULT 'webchat',
+    role            TEXT NOT NULL CHECK(role IN ('user','assistant','tool','system')),
+    content         TEXT NOT NULL,
+    tool_calls_json TEXT,
+    tool_call_id    TEXT,
+    token_count     INTEGER NOT NULL DEFAULT 0,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- SUMMARIES: compressed digests of long conversations
+  -- The Context Compiler uses the summary instead of full history
+  CREATE TABLE IF NOT EXISTS summaries (
+    thread_id         TEXT PRIMARY KEY,
+    summary           TEXT NOT NULL,
+    messages_covered  INTEGER NOT NULL DEFAULT 0,
+    last_message_id   INTEGER,
+    created_at        INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at        INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- SCRATCHPAD: persistent key-value notes per conversation
+  -- Survives context compression. Written by agents via save_note tool.
+  CREATE TABLE IF NOT EXISTS scratchpad (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    thread_id   TEXT NOT NULL,
+    key         TEXT NOT NULL,
+    value       TEXT NOT NULL,
+    source      TEXT,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    UNIQUE(thread_id, key)
+  );
+
+  -- TRACES: execution log for every agent invocation (ACE Generator output)
+  -- success: 1 = ok, 0 = failure
+  -- tokens_used: total tokens consumed in this invocation
+  CREATE TABLE IF NOT EXISTS traces (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    thread_id       TEXT NOT NULL,
+    agent_id        TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    agent_name      TEXT NOT NULL,
+    tool_used       TEXT,
+    input_summary   TEXT NOT NULL,
+    output_summary  TEXT NOT NULL,
+    success         INTEGER NOT NULL DEFAULT 1,
+    error_message   TEXT,
+    duration_ms     INTEGER,
+    tokens_used     INTEGER,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- REFLECTIONS: insights extracted by the ACE Reflector from traces
+  -- insight_type: 'success_pattern' | 'failure_pattern' | 'optimization' | 'ethics_violation'
+  -- confidence: 0.0 to 1.0
+  CREATE TABLE IF NOT EXISTS reflections (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    trace_ids       TEXT NOT NULL,
+    insight_type    TEXT NOT NULL CHECK(insight_type IN ('success_pattern','failure_pattern','optimization','ethics_violation')),
+    description     TEXT NOT NULL,
+    affected_tools  TEXT,
+    affected_agents TEXT,
+    confidence      REAL NOT NULL DEFAULT 0.5,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- PLAYBOOK: evolved rules injected by Context Compiler (ACE Curator output)
+  -- category: 'tool_selection' | 'response_quality' | 'error_avoidance' | 'optimization' | 'agent_creation'
+  -- applicable_to: JSON array of contexts where this rule applies
+  -- helpful_count / harmful_count: feedback from execution outcomes
+  -- active: 0 = pruned by Curator
+  CREATE TABLE IF NOT EXISTS playbook (
+    id                    INTEGER PRIMARY KEY AUTOINCREMENT,
+    rule                  TEXT NOT NULL,
+    category              TEXT NOT NULL CHECK(category IN ('tool_selection','response_quality','error_avoidance','optimization','agent_creation')),
+    applicable_to         TEXT,
+    helpful_count         INTEGER NOT NULL DEFAULT 0,
+    harmful_count         INTEGER NOT NULL DEFAULT 0,
+    source_reflection_id  INTEGER REFERENCES reflections(id) ON DELETE SET NULL,
+    active                INTEGER NOT NULL DEFAULT 1,
+    created_at            INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at            INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- TOOL_CACHE: cached results for deterministic/expensive tool calls
+  -- cache_key: hash of tool_id + serialized params
+  -- ttl_seconds: 0 = no expiry
+  CREATE TABLE IF NOT EXISTS tool_cache (
+    cache_key   TEXT PRIMARY KEY,
+    tool_id     TEXT NOT NULL,
+    result      TEXT NOT NULL,
+    ttl_seconds INTEGER NOT NULL DEFAULT 3600,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  -- FTS5 indexes for fast semantic search in Context Compiler
+  -- Created by initializeDatabase() via CONTEXT_ENGINE_SCHEMA
+  -- Populated by syncToolsToFTS() and syncSkillsToFTS() from gateway/initializer.ts
+  -- Triggers are NOT used - data is cleared and re-inserted on each sync to avoid schema drift
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS playbook_fts USING fts5(
+    rule,
+    category,
+    applicable_to
+  );
+
+  -- FTS5: tool catalog search (populated by syncToolCatalogToFTS from gateway/initializer.ts)
+  CREATE VIRTUAL TABLE IF NOT EXISTS tools_fts USING fts5(
+    tool_name,
+    name,
+    description,
+    category
+  );
+
+  -- FTS5: skills catalog search (populated by syncSkillsToFTS from gateway/initializer.ts)
+  -- Simplified schema - standalone FTS5 table (no content table sync)
+  -- Note: FTS5 tables are created programmatically in seed.ts to avoid "already exists" errors
+
+  -- REFRESH TOKENS: JWT refresh token storage (hash-based for security)
+  -- Stores hashed refresh tokens with expiry and user linkage
+  CREATE TABLE IF NOT EXISTS refresh_tokens (
+    id              TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    user_id         TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    token_hash      TEXT NOT NULL UNIQUE,
+    expires_at      INTEGER NOT NULL,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    revoked         INTEGER NOT NULL DEFAULT 0
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_refresh_tokens_user ON refresh_tokens(user_id);
+  CREATE INDEX IF NOT EXISTS idx_refresh_tokens_hash ON refresh_tokens(token_hash);
+  CREATE INDEX IF NOT EXISTS idx_refresh_tokens_expires ON refresh_tokens(expires_at);
+
+  -- Agent Bus: Message queue for worker-to-worker communication
+  CREATE TABLE IF NOT EXISTS agent_bus_messages (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_type      TEXT NOT NULL,
+    from_worker_id  TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    to_worker_id    TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    topic           TEXT,
+    content         TEXT NOT NULL,
+    metadata        TEXT,
+    created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+    read            INTEGER NOT NULL DEFAULT 0
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_agent_bus_from_worker ON agent_bus_messages(from_worker_id);
+  CREATE INDEX IF NOT EXISTS idx_agent_bus_to_worker ON agent_bus_messages(to_worker_id);
+  CREATE INDEX IF NOT EXISTS idx_agent_bus_event_type ON agent_bus_messages(event_type);
+  CREATE INDEX IF NOT EXISTS idx_agent_bus_read ON agent_bus_messages(read);
+
+  -- INDICES
+  CREATE INDEX IF NOT EXISTS idx_conversations_thread ON conversations(thread_id);
+  CREATE INDEX IF NOT EXISTS idx_conversations_role   ON conversations(role);
+  CREATE INDEX IF NOT EXISTS idx_scratchpad_thread    ON scratchpad(thread_id);
+  CREATE INDEX IF NOT EXISTS idx_traces_thread        ON traces(thread_id);
+  CREATE INDEX IF NOT EXISTS idx_traces_agent         ON traces(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_traces_success       ON traces(success);
+  CREATE INDEX IF NOT EXISTS idx_reflections_type     ON reflections(insight_type);
+  CREATE INDEX IF NOT EXISTS idx_playbook_active      ON playbook(active);
+  CREATE INDEX IF NOT EXISTS idx_playbook_category    ON playbook(category);
+  CREATE INDEX IF NOT EXISTS idx_tool_cache_tool      ON tool_cache(tool_id);
+
+
+`;
+
+// ../core/src/storage/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  initializeDatabase: () => initializeDatabase,
+  getDbPathLazy: () => getDbPathLazy,
+  getDb: () => getDb,
+  dbService: () => dbService,
+  DatabaseService: () => DatabaseService
+});
+import { Database } from "bun:sqlite";
+import * as path3 from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+function getDbPath() {
+  return path3.join(getHiveDir(), "data", "hive.db");
+}
+function getDbPathLazy() {
+  return getDbPath();
+}
+function getDb() {
+  if (!_db)
+    throw new Error("DB no inicializada. Llama initializeDatabase() primero.");
+  return _db;
+}
+function initializeDatabase() {
+  const hiveDir = getHiveDir();
+  const dir = path3.join(hiveDir, "data");
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const dbPath = getDbPath();
+  const dbFileExists = existsSync3(dbPath);
+  _db = new Database(dbPath, { create: true });
+  _db.exec(SCHEMA);
+  _db.exec(PROJECTS_SCHEMA);
+  _db.exec(CONTEXT_ENGINE_SCHEMA);
+  ensureSchemaSync();
+  return _db;
+}
+function ensureColumnExists(tableName, columnName, columnDefinition) {
+  if (!_db)
+    return;
+  try {
+    const info = _db.query(`PRAGMA table_info(${tableName})`).all();
+    const exists = info.some((col) => col.name === columnName);
+    if (!exists) {
+      logger.info(`\uD83D\uDEE0\uFE0F  A\xF1adiendo columna faltante '${columnName}' a la tabla '${tableName}'`);
+      _db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnDefinition}`);
+    }
+  } catch (err) {
+    logger.warn(`\u26A0\uFE0F  No se pudo verificar/a\xF1adir la columna '${columnName}' en '${tableName}':`, { error: err.message });
+  }
+}
+function ensureSchemaSync() {
+  if (!_db)
+    return;
+  ensureColumnExists("users", "email", "TEXT");
+  ensureColumnExists("users", "password_hash", "TEXT");
+  ensureColumnExists("mcp_servers", "tools_count", "INTEGER DEFAULT 0");
+  ensureColumnExists("mcp_servers", "status", "TEXT NOT NULL DEFAULT 'disconnected'");
+  ensureColumnExists("mcp_servers", "env_encrypted", "TEXT");
+  ensureColumnExists("mcp_servers", "env_iv", "TEXT");
+  ensureColumnExists("mcp_servers", "headers_encrypted", "TEXT");
+  ensureColumnExists("mcp_servers", "headers_iv", "TEXT");
+  ensureColumnExists("providers", "api_key_encrypted", "TEXT");
+  ensureColumnExists("providers", "api_key_iv", "TEXT");
+  ensureColumnExists("providers", "headers_encrypted", "TEXT");
+  ensureColumnExists("providers", "headers_iv", "TEXT");
+  ensureColumnExists("providers", "num_ctx", "INTEGER");
+  ensureColumnExists("providers", "num_gpu", "INTEGER DEFAULT -1");
+  ensureColumnExists("agents", "headers_encrypted", "TEXT");
+  ensureColumnExists("agents", "headers_iv", "TEXT");
+  ensureColumnExists("agents", "system_prompt", "TEXT");
+  ensureColumnExists("agents", "role", "TEXT NOT NULL DEFAULT 'coordinator'");
+  ensureColumnExists("agents", "tools_json", "TEXT");
+  ensureColumnExists("agents", "skills_json", "TEXT");
+  ensureColumnExists("agents", "parent_id", "TEXT");
+  ensureColumnExists("agents", "max_iterations", "INTEGER NOT NULL DEFAULT 10");
+  ensureColumnExists("agents", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("agents", "workspace", "TEXT");
+  ensureColumnExists("tasks", "priority", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumnExists("tasks", "depends_on", "TEXT");
+  ensureColumnExists("tasks", "error", "TEXT");
+  ensureColumnExists("tasks", "completed_at", "INTEGER");
+  ensureColumnExists("tools", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("tools", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("skills", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("skills", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("cron_jobs", "max_runs", "INTEGER");
+  ensureColumnExists("cron_jobs", "run_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumnExists("cron_jobs", "expires_at", "INTEGER");
+  ensureColumnExists("conversations", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("conversations", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("conversations", "reasoning_content", "TEXT");
+  ensureColumnExists("summaries", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("summaries", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("scratchpad", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("scratchpad", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("traces", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("reflections", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("playbook", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("playbook", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  ensureColumnExists("tool_cache", "created_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+  if (_db) {
+    _db.query(`UPDATE providers SET base_url = 'https://api.groq.com/openai/v1' WHERE id = 'groq' AND base_url = 'https://api.groq.com/v1'`).run();
+    _db.query(`UPDATE providers SET base_url = 'https://api.openai.com/v1' WHERE id = 'openai' AND base_url = 'https://api.openai.com'`).run();
+    _db.query(`UPDATE providers SET base_url = NULL WHERE id = 'gemini' AND base_url = 'https://generativelanguage.googleapis.com/v1beta'`).run();
+  }
+}
+
+class DatabaseService {
+  log = logger.child("sqlite");
+  get db() {
+    if (!_db) {
+      initializeDatabase();
+    }
+    return _db;
+  }
+  close() {
+    if (_db) {
+      _db.close();
+      _db = null;
+    }
+  }
+  updateMCPServer(id, updates) {
+    const fields = [];
+    const values = { $id: id };
+    if (updates.enabled !== undefined) {
+      fields.push("enabled = $enabled");
+      values.$enabled = updates.enabled ? 1 : 0;
+    }
+    if (updates.active !== undefined) {
+      fields.push("active = $active");
+      values.$active = updates.active ? 1 : 0;
+    }
+    if (updates.status !== undefined) {
+      fields.push("status = $status");
+      values.$status = updates.status;
+    }
+    if (updates.tools_count !== undefined) {
+      fields.push("tools_count = $tools_count");
+      values.$tools_count = updates.tools_count;
+    }
+    if (updates.transport !== undefined) {
+      fields.push("transport = $transport");
+      values.$transport = updates.transport;
+    }
+    if (updates.command !== undefined) {
+      fields.push("command = $command");
+      values.$command = updates.command;
+    }
+    if (updates.args !== undefined) {
+      fields.push("args = $args");
+      values.$args = JSON.stringify(updates.args);
+    }
+    if (updates.url !== undefined) {
+      fields.push("url = $url");
+      values.$url = updates.url;
+    }
+    if (updates.env_encrypted !== undefined) {
+      fields.push("env_encrypted = $env_encrypted");
+      values.$env_encrypted = updates.env_encrypted;
+    }
+    if (updates.env_iv !== undefined) {
+      fields.push("env_iv = $env_iv");
+      values.$env_iv = updates.env_iv;
+    }
+    if (updates.headers_encrypted !== undefined) {
+      fields.push("headers_encrypted = $headers_encrypted");
+      values.$headers_encrypted = updates.headers_encrypted;
+    }
+    if (updates.headers_iv !== undefined) {
+      fields.push("headers_iv = $headers_iv");
+      values.$headers_iv = updates.headers_iv;
+    }
+    if (fields.length === 0)
+      return;
+    const query = `UPDATE mcp_servers SET ${fields.join(", ")} WHERE id = $id`;
+    try {
+      this.db.query(query).run(values);
+      this.log.debug(`MCP server ${id} updated in DB`);
+    } catch (error) {
+      this.log.error(`Failed to update MCP server ${id}: ${error.message}`);
+    }
+  }
+  getActiveAgentWorkspace() {
+    try {
+      const row = this.db.query("SELECT workspace FROM agents WHERE role = 'coordinator' LIMIT 1").get();
+      const ws = row?.workspace;
+      return ws && ws !== "null" ? ws : null;
+    } catch {
+      return null;
+    }
+  }
+  listMCPServers() {
+    try {
+      return this.db.query("SELECT * FROM mcp_servers").all();
+    } catch (error) {
+      this.log.error(`Failed to list MCP servers: ${error.message}`);
+      return [];
+    }
+  }
+  createTask(task) {
+    const result = this.db.query(`
+            INSERT INTO tasks (project_id, agent_id, parent_task_id, name, description)
+            VALUES (?, ?, ?, ?, ?)
+        `).run(task.project_id, task.agent_id ?? null, task.parent_task_id ?? null, task.name, task.description ?? null);
+    return Number(result.lastInsertRowid);
+  }
+  updateTask(taskId, updates) {
+    const fields = ["updated_at = unixepoch()"];
+    const values = [];
+    if (updates.status !== undefined) {
+      fields.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.progress !== undefined) {
+      fields.push("progress = ?");
+      values.push(updates.progress);
+    }
+    if (updates.result !== undefined) {
+      fields.push("result = ?");
+      values.push(updates.result);
+    }
+    if (updates.agent_id !== undefined) {
+      fields.push("agent_id = ?");
+      values.push(updates.agent_id);
+    }
+    values.push(taskId);
+    const res = this.db.query(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+    return res.changes > 0;
+  }
+  getTasksByProject(projectId) {
+    return this.db.query("SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC").all(projectId);
+  }
+  getProjectWithTasks(projectId) {
+    const project = this.db.query("SELECT * FROM projects WHERE id = ?").get(projectId);
+    if (!project)
+      return null;
+    project.tasks = this.getTasksByProject(projectId);
+    return project;
+  }
+  recalcProjectProgress(projectId) {
+    const row = this.db.query("SELECT AVG(progress) as avg_progress FROM tasks WHERE project_id = ?").get(projectId);
+    const avg = Math.round(row?.avg_progress ?? 0);
+    this.db.query("UPDATE projects SET progress = ?, updated_at = unixepoch() WHERE id = ?").run(avg, projectId);
+    return avg;
+  }
+  saveMCPServer(server) {
+    try {
+      this.db.query(`
+                INSERT OR REPLACE INTO mcp_servers (id, name, transport, command, args, url, env_encrypted, env_iv, headers_encrypted, headers_iv, enabled, active, builtin, tools_count, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(server.id || server.name, server.name, server.transport, server.command || null, JSON.stringify(server.args || []), server.url || null, server.env_encrypted || null, server.env_iv || null, server.headers_encrypted || null, server.headers_iv || null, server.enabled ? 1 : 0, server.active ? 1 : 0, server.builtin ? 1 : 0, server.tools_count || 0, server.status || "disconnected");
+    } catch (error) {
+      this.log.error(`Failed to save MCP server ${server.name}: ${error.message}`);
+    }
+  }
+}
+var _db = null, dbService;
+var init_sqlite = __esm(() => {
+  init_logger();
+  init_loader();
+  dbService = new DatabaseService;
+});
+
+// ../../node_modules/.bun/croner@10.0.1/node_modules/croner/dist/croner.js
+function T(s) {
+  return Date.UTC(s.y, s.m - 1, s.d, s.h, s.i, s.s);
+}
+function D(s, e) {
+  return s.y === e.y && s.m === e.m && s.d === e.d && s.h === e.h && s.i === e.i && s.s === e.s;
+}
+function A(s, e) {
+  let t = new Date(Date.parse(s));
+  if (isNaN(t))
+    throw new Error("Invalid ISO8601 passed to timezone parser.");
+  let r = s.substring(9);
+  return r.includes("Z") || r.includes("+") || r.includes("-") ? b(t.getUTCFullYear(), t.getUTCMonth() + 1, t.getUTCDate(), t.getUTCHours(), t.getUTCMinutes(), t.getUTCSeconds(), "Etc/UTC") : b(t.getFullYear(), t.getMonth() + 1, t.getDate(), t.getHours(), t.getMinutes(), t.getSeconds(), e);
+}
+function v(s, e, t) {
+  return k(A(s, e), t);
+}
+function k(s, e) {
+  let t = new Date(T(s)), r = g(t, s.tz), n = T(s), i = T(r), a = n - i, o = new Date(t.getTime() + a), h = g(o, s.tz);
+  if (D(h, s)) {
+    let u = new Date(o.getTime() - 3600000), d = g(u, s.tz);
+    return D(d, s) ? u : o;
+  }
+  let l = new Date(o.getTime() + T(s) - T(h)), y = g(l, s.tz);
+  if (D(y, s))
+    return l;
+  if (e)
+    throw new Error("Invalid date passed to fromTZ()");
+  return o.getTime() > l.getTime() ? o : l;
+}
+function g(s, e) {
+  let t, r;
+  try {
+    t = new Intl.DateTimeFormat("en-US", { timeZone: e, year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric", hour12: false }), r = t.formatToParts(s);
+  } catch (i) {
+    let a = i instanceof Error ? i.message : String(i);
+    throw new RangeError(`toTZ: Invalid timezone '${e}' or date. Please provide a valid IANA timezone (e.g., 'America/New_York', 'Europe/Stockholm'). Original error: ${a}`);
+  }
+  let n = { year: 0, month: 0, day: 0, hour: 0, minute: 0, second: 0 };
+  for (let i of r)
+    (i.type === "year" || i.type === "month" || i.type === "day" || i.type === "hour" || i.type === "minute" || i.type === "second") && (n[i.type] = parseInt(i.value, 10));
+  if (isNaN(n.year) || isNaN(n.month) || isNaN(n.day) || isNaN(n.hour) || isNaN(n.minute) || isNaN(n.second))
+    throw new Error(`toTZ: Failed to parse all date components from timezone '${e}'. This may indicate an invalid date or timezone configuration. Parsed components: ${JSON.stringify(n)}`);
+  return n.hour === 24 && (n.hour = 0), { y: n.year, m: n.month, d: n.day, h: n.hour, i: n.minute, s: n.second, tz: e };
+}
+function b(s, e, t, r, n, i, a) {
+  return { y: s, m: e, d: t, h: r, i: n, s: i, tz: a };
+}
+function R(s2) {
+  if (s2 === undefined && (s2 = {}), delete s2.name, s2.legacyMode !== undefined && s2.domAndDow === undefined ? s2.domAndDow = !s2.legacyMode : s2.domAndDow === undefined && (s2.domAndDow = false), s2.legacyMode = !s2.domAndDow, s2.paused = s2.paused === undefined ? false : s2.paused, s2.maxRuns = s2.maxRuns === undefined ? 1 / 0 : s2.maxRuns, s2.catch = s2.catch === undefined ? false : s2.catch, s2.interval = s2.interval === undefined ? 0 : parseInt(s2.interval.toString(), 10), s2.utcOffset = s2.utcOffset === undefined ? undefined : parseInt(s2.utcOffset.toString(), 10), s2.dayOffset = s2.dayOffset === undefined ? 0 : parseInt(s2.dayOffset.toString(), 10), s2.unref = s2.unref === undefined ? false : s2.unref, s2.mode = s2.mode === undefined ? "auto" : s2.mode, s2.alternativeWeekdays = s2.alternativeWeekdays === undefined ? false : s2.alternativeWeekdays, s2.sloppyRanges = s2.sloppyRanges === undefined ? false : s2.sloppyRanges, !["auto", "5-part", "6-part", "7-part", "5-or-6-parts", "6-or-7-parts"].includes(s2.mode))
+    throw new Error("CronOptions: mode must be one of 'auto', '5-part', '6-part', '7-part', '5-or-6-parts', or '6-or-7-parts'.");
+  if (s2.startAt && (s2.startAt = new m(s2.startAt, s2.timezone)), s2.stopAt && (s2.stopAt = new m(s2.stopAt, s2.timezone)), s2.interval !== null) {
+    if (isNaN(s2.interval))
+      throw new Error("CronOptions: Supplied value for interval is not a number");
+    if (s2.interval < 0)
+      throw new Error("CronOptions: Supplied value for interval can not be negative");
+  }
+  if (s2.utcOffset !== undefined) {
+    if (isNaN(s2.utcOffset))
+      throw new Error("CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.");
+    if (s2.utcOffset < -870 || s2.utcOffset > 870)
+      throw new Error("CronOptions: utcOffset out of bounds.");
+    if (s2.utcOffset !== undefined && s2.timezone)
+      throw new Error("CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.");
+  }
+  if (s2.unref !== true && s2.unref !== false)
+    throw new Error("CronOptions: Unref should be either true, false or undefined(false).");
+  if (s2.dayOffset !== undefined && s2.dayOffset !== 0 && isNaN(s2.dayOffset))
+    throw new Error("CronOptions: Invalid value passed for dayOffset, should be a number representing days to offset.");
+  return s2;
+}
+function p(s2) {
+  return Object.prototype.toString.call(s2) === "[object Function]" || typeof s2 == "function" || s2 instanceof Function;
+}
+function _(s2) {
+  return p(s2);
+}
+function x(s2) {
+  typeof Deno < "u" && typeof Deno.unrefTimer < "u" ? Deno.unrefTimer(s2) : s2 && typeof s2.unref < "u" && s2.unref();
+}
+var O, C = class {
+  pattern;
+  timezone;
+  mode;
+  alternativeWeekdays;
+  sloppyRanges;
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  dayOfWeek;
+  year;
+  lastDayOfMonth;
+  lastWeekday;
+  nearestWeekdays;
+  starDOM;
+  starDOW;
+  starYear;
+  useAndLogic;
+  constructor(e, t, r) {
+    this.pattern = e, this.timezone = t, this.mode = r?.mode ?? "auto", this.alternativeWeekdays = r?.alternativeWeekdays ?? false, this.sloppyRanges = r?.sloppyRanges ?? false, this.second = Array(60).fill(0), this.minute = Array(60).fill(0), this.hour = Array(24).fill(0), this.day = Array(31).fill(0), this.month = Array(12).fill(0), this.dayOfWeek = Array(7).fill(0), this.year = Array(1e4).fill(0), this.lastDayOfMonth = false, this.lastWeekday = false, this.nearestWeekdays = Array(31).fill(0), this.starDOM = false, this.starDOW = false, this.starYear = false, this.useAndLogic = false, this.parse();
+  }
+  parse() {
+    if (!(typeof this.pattern == "string" || this.pattern instanceof String))
+      throw new TypeError("CronPattern: Pattern has to be of type string.");
+    this.pattern.indexOf("@") >= 0 && (this.pattern = this.handleNicknames(this.pattern).trim());
+    let e = this.pattern.match(/\S+/g) || [""], t = e.length;
+    if (e.length < 5 || e.length > 7)
+      throw new TypeError("CronPattern: invalid configuration format ('" + this.pattern + "'), exactly five, six, or seven space separated parts are required.");
+    if (this.mode !== "auto") {
+      let n;
+      switch (this.mode) {
+        case "5-part":
+          n = 5;
+          break;
+        case "6-part":
+          n = 6;
+          break;
+        case "7-part":
+          n = 7;
+          break;
+        case "5-or-6-parts":
+          n = [5, 6];
+          break;
+        case "6-or-7-parts":
+          n = [6, 7];
+          break;
+        default:
+          n = 0;
+      }
+      if (!(Array.isArray(n) ? n.includes(t) : t === n)) {
+        let a = Array.isArray(n) ? n.join(" or ") : n.toString();
+        throw new TypeError(`CronPattern: mode '${this.mode}' requires exactly ${a} parts, but pattern '${this.pattern}' has ${t} parts.`);
+      }
+    }
+    if (e.length === 5 && e.unshift("0"), e.length === 6 && e.push("*"), e[3].toUpperCase() === "LW" ? (this.lastWeekday = true, e[3] = "") : e[3].toUpperCase().indexOf("L") >= 0 && (e[3] = e[3].replace(/L/gi, ""), this.lastDayOfMonth = true), e[3] == "*" && (this.starDOM = true), e[6] == "*" && (this.starYear = true), e[4].length >= 3 && (e[4] = this.replaceAlphaMonths(e[4])), e[5].length >= 3 && (e[5] = this.alternativeWeekdays ? this.replaceAlphaDaysQuartz(e[5]) : this.replaceAlphaDays(e[5])), e[5].startsWith("+") && (this.useAndLogic = true, e[5] = e[5].substring(1), e[5] === ""))
+      throw new TypeError("CronPattern: Day-of-week field cannot be empty after '+' modifier.");
+    switch (e[5] == "*" && (this.starDOW = true), this.pattern.indexOf("?") >= 0 && (e[0] = e[0].replace(/\?/g, "*"), e[1] = e[1].replace(/\?/g, "*"), e[2] = e[2].replace(/\?/g, "*"), e[3] = e[3].replace(/\?/g, "*"), e[4] = e[4].replace(/\?/g, "*"), e[5] = e[5].replace(/\?/g, "*"), e[6] && (e[6] = e[6].replace(/\?/g, "*"))), this.mode) {
+      case "5-part":
+        e[0] = "0", e[6] = "*";
+        break;
+      case "6-part":
+        e[6] = "*";
+        break;
+      case "5-or-6-parts":
+        e[6] = "*";
+        break;
+      case "6-or-7-parts":
+        break;
+      case "7-part":
+      case "auto":
+        break;
+    }
+    this.throwAtIllegalCharacters(e), this.partToArray("second", e[0], 0, 1), this.partToArray("minute", e[1], 0, 1), this.partToArray("hour", e[2], 0, 1), this.partToArray("day", e[3], -1, 1), this.partToArray("month", e[4], -1, 1);
+    let r = this.alternativeWeekdays ? -1 : 0;
+    this.partToArray("dayOfWeek", e[5], r, 63), this.partToArray("year", e[6], 0, 1), !this.alternativeWeekdays && this.dayOfWeek[7] && (this.dayOfWeek[0] = this.dayOfWeek[7]);
+  }
+  partToArray(e, t, r, n) {
+    let i = this[e], a = e === "day" && this.lastDayOfMonth, o = e === "day" && this.lastWeekday;
+    if (t === "" && !a && !o)
+      throw new TypeError("CronPattern: configuration entry " + e + " (" + t + ") is empty, check for trailing spaces.");
+    if (t === "*")
+      return i.fill(n);
+    let h = t.split(",");
+    if (h.length > 1)
+      for (let l = 0;l < h.length; l++)
+        this.partToArray(e, h[l], r, n);
+    else
+      t.indexOf("-") !== -1 && t.indexOf("/") !== -1 ? this.handleRangeWithStepping(t, e, r, n) : t.indexOf("-") !== -1 ? this.handleRange(t, e, r, n) : t.indexOf("/") !== -1 ? this.handleStepping(t, e, r, n) : t !== "" && this.handleNumber(t, e, r, n);
+  }
+  throwAtIllegalCharacters(e) {
+    for (let t = 0;t < e.length; t++)
+      if ((t === 3 ? /[^/*0-9,\-WwLl]+/ : t === 5 ? /[^/*0-9,\-#Ll]+/ : /[^/*0-9,\-]+/).test(e[t]))
+        throw new TypeError("CronPattern: configuration entry " + t + " (" + e[t] + ") contains illegal characters.");
+  }
+  handleNumber(e, t, r, n) {
+    let i = this.extractNth(e, t), a = e.toUpperCase().includes("W");
+    if (t !== "day" && a)
+      throw new TypeError("CronPattern: Nearest weekday modifier (W) only allowed in day-of-month.");
+    a && (t = "nearestWeekdays");
+    let o = parseInt(i[0], 10) + r;
+    if (isNaN(o))
+      throw new TypeError("CronPattern: " + t + " is not a number: '" + e + "'");
+    this.setPart(t, o, i[1] || n);
+  }
+  setPart(e, t, r) {
+    if (!Object.prototype.hasOwnProperty.call(this, e))
+      throw new TypeError("CronPattern: Invalid part specified: " + e);
+    if (e === "dayOfWeek") {
+      if (t === 7 && (t = 0), t < 0 || t > 6)
+        throw new RangeError("CronPattern: Invalid value for dayOfWeek: " + t);
+      this.setNthWeekdayOfMonth(t, r);
+      return;
+    }
+    if (e === "second" || e === "minute") {
+      if (t < 0 || t >= 60)
+        throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "hour") {
+      if (t < 0 || t >= 24)
+        throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "day" || e === "nearestWeekdays") {
+      if (t < 0 || t >= 31)
+        throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "month") {
+      if (t < 0 || t >= 12)
+        throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "year" && (t < 1 || t >= 1e4))
+      throw new RangeError("CronPattern: Invalid value for " + e + ": " + t + " (supported range: 1-9999)");
+    this[e][t] = r;
+  }
+  validateNotNaN(e, t) {
+    if (isNaN(e))
+      throw new TypeError(t);
+  }
+  validateRange(e, t, r, n, i) {
+    if (e > t)
+      throw new TypeError("CronPattern: From value is larger than to value: '" + i + "'");
+    if (r !== undefined) {
+      if (r === 0)
+        throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+      if (r > this[n].length)
+        throw new TypeError("CronPattern: Syntax error, steps cannot be greater than maximum value of part (" + this[n].length + ")");
+    }
+  }
+  handleRangeWithStepping(e, t, r, n) {
+    if (e.toUpperCase().includes("W"))
+      throw new TypeError("CronPattern: Syntax error, W is not allowed in ranges with stepping.");
+    let i = this.extractNth(e, t), a = i[0].match(/^(\d+)-(\d+)\/(\d+)$/);
+    if (a === null)
+      throw new TypeError("CronPattern: Syntax error, illegal range with stepping: '" + e + "'");
+    let [, o, h, l] = a, y = parseInt(o, 10) + r, u = parseInt(h, 10) + r, d = parseInt(l, 10);
+    this.validateNotNaN(y, "CronPattern: Syntax error, illegal lower range (NaN)"), this.validateNotNaN(u, "CronPattern: Syntax error, illegal upper range (NaN)"), this.validateNotNaN(d, "CronPattern: Syntax error, illegal stepping: (NaN)"), this.validateRange(y, u, d, t, e);
+    for (let c = y;c <= u; c += d)
+      this.setPart(t, c, i[1] || n);
+  }
+  extractNth(e, t) {
+    let r = e, n;
+    if (r.includes("#")) {
+      if (t !== "dayOfWeek")
+        throw new Error("CronPattern: nth (#) only allowed in day-of-week field");
+      n = r.split("#")[1], r = r.split("#")[0];
+    } else if (r.toUpperCase().endsWith("L")) {
+      if (t !== "dayOfWeek")
+        throw new Error("CronPattern: L modifier only allowed in day-of-week field (use L alone for day-of-month)");
+      n = "L", r = r.slice(0, -1);
+    }
+    return [r, n];
+  }
+  handleRange(e, t, r, n) {
+    if (e.toUpperCase().includes("W"))
+      throw new TypeError("CronPattern: Syntax error, W is not allowed in a range.");
+    let i = this.extractNth(e, t), a = i[0].split("-");
+    if (a.length !== 2)
+      throw new TypeError("CronPattern: Syntax error, illegal range: '" + e + "'");
+    let o = parseInt(a[0], 10) + r, h = parseInt(a[1], 10) + r;
+    this.validateNotNaN(o, "CronPattern: Syntax error, illegal lower range (NaN)"), this.validateNotNaN(h, "CronPattern: Syntax error, illegal upper range (NaN)"), this.validateRange(o, h, undefined, t, e);
+    for (let l = o;l <= h; l++)
+      this.setPart(t, l, i[1] || n);
+  }
+  handleStepping(e, t, r, n) {
+    if (e.toUpperCase().includes("W"))
+      throw new TypeError("CronPattern: Syntax error, W is not allowed in parts with stepping.");
+    let i = this.extractNth(e, t), a = i[0].split("/");
+    if (a.length !== 2)
+      throw new TypeError("CronPattern: Syntax error, illegal stepping: '" + e + "'");
+    if (this.sloppyRanges)
+      a[0] === "" && (a[0] = "*");
+    else {
+      if (a[0] === "")
+        throw new TypeError("CronPattern: Syntax error, stepping with missing prefix ('" + e + "') is not allowed. Use wildcard (*/step) or range (min-max/step) instead.");
+      if (a[0] !== "*")
+        throw new TypeError("CronPattern: Syntax error, stepping with numeric prefix ('" + e + "') is not allowed. Use wildcard (*/step) or range (min-max/step) instead.");
+    }
+    let o = 0;
+    a[0] !== "*" && (o = parseInt(a[0], 10) + r);
+    let h = parseInt(a[1], 10);
+    this.validateNotNaN(h, "CronPattern: Syntax error, illegal stepping: (NaN)"), this.validateRange(0, this[t].length - 1, h, t, e);
+    for (let l = o;l < this[t].length; l += h)
+      this.setPart(t, l, i[1] || n);
+  }
+  replaceAlphaDays(e) {
+    return e.replace(/-sun/gi, "-7").replace(/sun/gi, "0").replace(/mon/gi, "1").replace(/tue/gi, "2").replace(/wed/gi, "3").replace(/thu/gi, "4").replace(/fri/gi, "5").replace(/sat/gi, "6");
+  }
+  replaceAlphaDaysQuartz(e) {
+    return e.replace(/sun/gi, "1").replace(/mon/gi, "2").replace(/tue/gi, "3").replace(/wed/gi, "4").replace(/thu/gi, "5").replace(/fri/gi, "6").replace(/sat/gi, "7");
+  }
+  replaceAlphaMonths(e) {
+    return e.replace(/jan/gi, "1").replace(/feb/gi, "2").replace(/mar/gi, "3").replace(/apr/gi, "4").replace(/may/gi, "5").replace(/jun/gi, "6").replace(/jul/gi, "7").replace(/aug/gi, "8").replace(/sep/gi, "9").replace(/oct/gi, "10").replace(/nov/gi, "11").replace(/dec/gi, "12");
+  }
+  handleNicknames(e) {
+    let t = e.trim().toLowerCase();
+    if (t === "@yearly" || t === "@annually")
+      return "0 0 1 1 *";
+    if (t === "@monthly")
+      return "0 0 1 * *";
+    if (t === "@weekly")
+      return "0 0 * * 0";
+    if (t === "@daily" || t === "@midnight")
+      return "0 0 * * *";
+    if (t === "@hourly")
+      return "0 * * * *";
+    if (t === "@reboot")
+      throw new TypeError("CronPattern: @reboot is not supported in this environment. This is an event-based trigger that requires system startup detection.");
+    return e;
+  }
+  setNthWeekdayOfMonth(e, t) {
+    if (typeof t != "number" && t.toUpperCase() === "L")
+      this.dayOfWeek[e] = this.dayOfWeek[e] | 32;
+    else if (t === 63)
+      this.dayOfWeek[e] = 63;
+    else if (t < 6 && t > 0)
+      this.dayOfWeek[e] = this.dayOfWeek[e] | O[t - 1];
+    else
+      throw new TypeError(`CronPattern: nth weekday out of range, should be 1-5 or L. Value: ${t}, Type: ${typeof t}`);
+  }
+}, P, f, m = class s {
+  tz;
+  ms;
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  year;
+  constructor(e, t) {
+    if (this.tz = t, e && e instanceof Date)
+      if (!isNaN(e))
+        this.fromDate(e);
+      else
+        throw new TypeError("CronDate: Invalid date passed to CronDate constructor");
+    else if (e == null)
+      this.fromDate(new Date);
+    else if (e && typeof e == "string")
+      this.fromString(e);
+    else if (e instanceof s)
+      this.fromCronDate(e);
+    else
+      throw new TypeError("CronDate: Invalid type (" + typeof e + ") passed to CronDate constructor");
+  }
+  getLastDayOfMonth(e, t) {
+    return t !== 1 ? P[t] : new Date(Date.UTC(e, t + 1, 0)).getUTCDate();
+  }
+  getLastWeekday(e, t) {
+    let r = this.getLastDayOfMonth(e, t), i = new Date(Date.UTC(e, t, r)).getUTCDay();
+    return i === 0 ? r - 2 : i === 6 ? r - 1 : r;
+  }
+  getNearestWeekday(e, t, r) {
+    let n = this.getLastDayOfMonth(e, t);
+    if (r > n)
+      return -1;
+    let a = new Date(Date.UTC(e, t, r)).getUTCDay();
+    return a === 0 ? r === n ? r - 2 : r + 1 : a === 6 ? r === 1 ? r + 2 : r - 1 : r;
+  }
+  isNthWeekdayOfMonth(e, t, r, n) {
+    let a = new Date(Date.UTC(e, t, r)).getUTCDay(), o = 0;
+    for (let h = 1;h <= r; h++)
+      new Date(Date.UTC(e, t, h)).getUTCDay() === a && o++;
+    if (n & 63 && O[o - 1] & n)
+      return true;
+    if (n & 32) {
+      let h = this.getLastDayOfMonth(e, t);
+      for (let l = r + 1;l <= h; l++)
+        if (new Date(Date.UTC(e, t, l)).getUTCDay() === a)
+          return false;
+      return true;
+    }
+    return false;
+  }
+  fromDate(e) {
+    if (this.tz !== undefined)
+      if (typeof this.tz == "number")
+        this.ms = e.getUTCMilliseconds(), this.second = e.getUTCSeconds(), this.minute = e.getUTCMinutes() + this.tz, this.hour = e.getUTCHours(), this.day = e.getUTCDate(), this.month = e.getUTCMonth(), this.year = e.getUTCFullYear(), this.apply();
+      else
+        try {
+          let t = g(e, this.tz);
+          this.ms = e.getMilliseconds(), this.second = t.s, this.minute = t.i, this.hour = t.h, this.day = t.d, this.month = t.m - 1, this.year = t.y;
+        } catch (t) {
+          let r = t instanceof Error ? t.message : String(t);
+          throw new TypeError(`CronDate: Failed to convert date to timezone '${this.tz}'. This may happen with invalid timezone names or dates. Original error: ${r}`);
+        }
+    else
+      this.ms = e.getMilliseconds(), this.second = e.getSeconds(), this.minute = e.getMinutes(), this.hour = e.getHours(), this.day = e.getDate(), this.month = e.getMonth(), this.year = e.getFullYear();
+  }
+  fromCronDate(e) {
+    this.tz = e.tz, this.year = e.year, this.month = e.month, this.day = e.day, this.hour = e.hour, this.minute = e.minute, this.second = e.second, this.ms = e.ms;
+  }
+  apply() {
+    if (this.month > 11 || this.month < 0 || this.day > P[this.month] || this.day < 1 || this.hour > 59 || this.minute > 59 || this.second > 59 || this.hour < 0 || this.minute < 0 || this.second < 0) {
+      let e = new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms));
+      return this.ms = e.getUTCMilliseconds(), this.second = e.getUTCSeconds(), this.minute = e.getUTCMinutes(), this.hour = e.getUTCHours(), this.day = e.getUTCDate(), this.month = e.getUTCMonth(), this.year = e.getUTCFullYear(), true;
+    } else
+      return false;
+  }
+  fromString(e) {
+    if (typeof this.tz == "number") {
+      let t = v(e);
+      this.ms = t.getUTCMilliseconds(), this.second = t.getUTCSeconds(), this.minute = t.getUTCMinutes(), this.hour = t.getUTCHours(), this.day = t.getUTCDate(), this.month = t.getUTCMonth(), this.year = t.getUTCFullYear(), this.apply();
+    } else
+      return this.fromDate(v(e, this.tz));
+  }
+  findNext(e, t, r, n) {
+    return this._findMatch(e, t, r, n, 1);
+  }
+  _findMatch(e, t, r, n, i) {
+    let a = this[t], o;
+    r.lastDayOfMonth && (o = this.getLastDayOfMonth(this.year, this.month));
+    let h = !r.starDOW && t == "day" ? new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay() : undefined, l = this[t] + n, y = i === 1 ? (u) => u < r[t].length : (u) => u >= 0;
+    for (let u = l;y(u); u += i) {
+      let d = r[t][u];
+      if (t === "day" && !d) {
+        for (let c = 0;c < r.nearestWeekdays.length; c++)
+          if (r.nearestWeekdays[c]) {
+            let M = this.getNearestWeekday(this.year, this.month, c - n);
+            if (M === -1)
+              continue;
+            if (M === u - n) {
+              d = 1;
+              break;
+            }
+          }
+      }
+      if (t === "day" && r.lastWeekday) {
+        let c = this.getLastWeekday(this.year, this.month);
+        u - n === c && (d = 1);
+      }
+      if (t === "day" && r.lastDayOfMonth && u - n == o && (d = 1), t === "day" && !r.starDOW) {
+        let c = r.dayOfWeek[(h + (u - n - 1)) % 7];
+        if (c && c & 63)
+          c = this.isNthWeekdayOfMonth(this.year, this.month, u - n, c) ? 1 : 0;
+        else if (c)
+          throw new Error(`CronDate: Invalid value for dayOfWeek encountered. ${c}`);
+        r.useAndLogic ? d = d && c : !e.domAndDow && !r.starDOM ? d = d || c : d = d && c;
+      }
+      if (d)
+        return this[t] = u - n, a !== this[t] ? 2 : 1;
+    }
+    return 3;
+  }
+  recurse(e, t, r) {
+    if (r === 0 && !e.starYear) {
+      if (this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0) {
+        let i = -1;
+        for (let a = this.year + 1;a < e.year.length && a < 1e4; a++)
+          if (e.year[a] === 1) {
+            i = a;
+            break;
+          }
+        if (i === -1)
+          return null;
+        this.year = i, this.month = 0, this.day = 1, this.hour = 0, this.minute = 0, this.second = 0, this.ms = 0;
+      }
+      if (this.year >= 1e4)
+        return null;
+    }
+    let n = this.findNext(t, f[r][0], e, f[r][2]);
+    if (n > 1) {
+      let i = r + 1;
+      for (;i < f.length; )
+        this[f[i][0]] = -f[i][2], i++;
+      if (n === 3) {
+        if (this[f[r][1]]++, this[f[r][0]] = -f[r][2], this.apply(), r === 0 && !e.starYear) {
+          for (;this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0 && this.year < 1e4; )
+            this.year++;
+          if (this.year >= 1e4 || this.year >= e.year.length)
+            return null;
+        }
+        return this.recurse(e, t, 0);
+      } else if (this.apply())
+        return this.recurse(e, t, r - 1);
+    }
+    return r += 1, r >= f.length ? this : (e.starYear ? this.year >= 3000 : this.year >= 1e4) ? null : this.recurse(e, t, r);
+  }
+  increment(e, t, r) {
+    return this.second += t.interval !== undefined && t.interval > 1 && r ? t.interval : 1, this.ms = 0, this.apply(), this.recurse(e, t, 0);
+  }
+  decrement(e, t) {
+    return this.second -= t.interval !== undefined && t.interval > 1 ? t.interval : 1, this.ms = 0, this.apply(), this.recurseBackward(e, t, 0, 0);
+  }
+  recurseBackward(e, t, r, n = 0) {
+    if (n > 1e4)
+      return null;
+    if (r === 0 && !e.starYear) {
+      if (this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0) {
+        let a = -1;
+        for (let o = this.year - 1;o >= 0; o--)
+          if (e.year[o] === 1) {
+            a = o;
+            break;
+          }
+        if (a === -1)
+          return null;
+        this.year = a, this.month = 11, this.day = 31, this.hour = 23, this.minute = 59, this.second = 59, this.ms = 0;
+      }
+      if (this.year < 0)
+        return null;
+    }
+    let i = this.findPrevious(t, f[r][0], e, f[r][2]);
+    if (i > 1) {
+      let a = r + 1;
+      for (;a < f.length; ) {
+        let o = f[a][0], h = f[a][2], l = this.getMaxPatternValue(o, e, h);
+        this[o] = l, a++;
+      }
+      if (i === 3) {
+        if (this[f[r][1]]--, r === 0) {
+          let y = this.getLastDayOfMonth(this.year, this.month);
+          this.day > y && (this.day = y);
+        }
+        if (r === 1)
+          if (this.day <= 0)
+            this.day = 1;
+          else {
+            let y = this.year, u = this.month;
+            for (;u < 0; )
+              u += 12, y--;
+            for (;u > 11; )
+              u -= 12, y++;
+            let d = u !== 1 ? P[u] : new Date(Date.UTC(y, u + 1, 0)).getUTCDate();
+            this.day > d && (this.day = d);
+          }
+        this.apply();
+        let o = f[r][0], h = f[r][2], l = this.getMaxPatternValue(o, e, h);
+        if (o === "day") {
+          let y = this.getLastDayOfMonth(this.year, this.month);
+          this[o] = Math.min(l, y);
+        } else
+          this[o] = l;
+        if (this.apply(), r === 0) {
+          let y = f[1][2], u = this.getMaxPatternValue("day", e, y), d = this.getLastDayOfMonth(this.year, this.month), c = Math.min(u, d);
+          c !== this.day && (this.day = c, this.hour = this.getMaxPatternValue("hour", e, f[2][2]), this.minute = this.getMaxPatternValue("minute", e, f[3][2]), this.second = this.getMaxPatternValue("second", e, f[4][2]));
+        }
+        if (r === 0 && !e.starYear) {
+          for (;this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0; )
+            this.year--;
+          if (this.year < 0)
+            return null;
+        }
+        return this.recurseBackward(e, t, 0, n + 1);
+      } else if (this.apply())
+        return this.recurseBackward(e, t, r - 1, n + 1);
+    }
+    return r += 1, r >= f.length ? this : this.year < 0 ? null : this.recurseBackward(e, t, r, n + 1);
+  }
+  getMaxPatternValue(e, t, r) {
+    if (e === "day" && t.lastDayOfMonth)
+      return this.getLastDayOfMonth(this.year, this.month);
+    if (e === "day" && !t.starDOW)
+      return this.getLastDayOfMonth(this.year, this.month);
+    for (let n = t[e].length - 1;n >= 0; n--)
+      if (t[e][n])
+        return n - r;
+    return t[e].length - 1 - r;
+  }
+  findPrevious(e, t, r, n) {
+    return this._findMatch(e, t, r, n, -1);
+  }
+  getDate(e) {
+    return e || this.tz === undefined ? new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms) : typeof this.tz == "number" ? new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute - this.tz, this.second, this.ms)) : k(b(this.year, this.month + 1, this.day, this.hour, this.minute, this.second, this.tz), false);
+  }
+  getTime() {
+    return this.getDate(false).getTime();
+  }
+  match(e, t) {
+    if (!e.starYear && (this.year < 0 || this.year >= e.year.length || e.year[this.year] === 0))
+      return false;
+    for (let r = 0;r < f.length; r++) {
+      let n = f[r][0], i = f[r][2], a = this[n];
+      if (a + i < 0 || a + i >= e[n].length)
+        return false;
+      let o = e[n][a + i];
+      if (n === "day") {
+        if (!o) {
+          for (let h = 0;h < e.nearestWeekdays.length; h++)
+            if (e.nearestWeekdays[h]) {
+              let l = this.getNearestWeekday(this.year, this.month, h - i);
+              if (l !== -1 && l === a) {
+                o = 1;
+                break;
+              }
+            }
+        }
+        if (e.lastWeekday) {
+          let h = this.getLastWeekday(this.year, this.month);
+          a === h && (o = 1);
+        }
+        if (e.lastDayOfMonth) {
+          let h = this.getLastDayOfMonth(this.year, this.month);
+          a === h && (o = 1);
+        }
+        if (!e.starDOW) {
+          let h = new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay(), l = e.dayOfWeek[(h + (a - 1)) % 7];
+          l && l & 63 && (l = this.isNthWeekdayOfMonth(this.year, this.month, a, l) ? 1 : 0), e.useAndLogic ? o = o && l : !t.domAndDow && !e.starDOM ? o = o || l : o = o && l;
+        }
+      }
+      if (!o)
+        return false;
+    }
+    return true;
+  }
+}, W, w, E = class {
+  name;
+  options;
+  _states;
+  fn;
+  getTz() {
+    return this.options.timezone || this.options.utcOffset;
+  }
+  applyDayOffset(e) {
+    if (this.options.dayOffset !== undefined && this.options.dayOffset !== 0) {
+      let t = this.options.dayOffset * 24 * 60 * 60 * 1000;
+      return new Date(e.getTime() + t);
+    }
+    return e;
+  }
+  constructor(e, t, r) {
+    let n, i;
+    if (p(t))
+      i = t;
+    else if (typeof t == "object")
+      n = t;
+    else if (t !== undefined)
+      throw new Error("Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).");
+    if (p(r))
+      i = r;
+    else if (typeof r == "object")
+      n = r;
+    else if (r !== undefined)
+      throw new Error("Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).");
+    if (this.name = n?.name, this.options = R(n), this._states = { kill: false, blocking: false, previousRun: undefined, currentRun: undefined, once: undefined, currentTimeout: undefined, maxRuns: n ? n.maxRuns : undefined, paused: n ? n.paused : false, pattern: new C("* * * * *", undefined, { mode: "auto" }) }, e && (e instanceof Date || typeof e == "string" && e.indexOf(":") > 0) ? this._states.once = new m(e, this.getTz()) : this._states.pattern = new C(e, this.options.timezone, { mode: this.options.mode, alternativeWeekdays: this.options.alternativeWeekdays, sloppyRanges: this.options.sloppyRanges }), this.name) {
+      if (w.find((o) => o.name === this.name))
+        throw new Error("Cron: Tried to initialize new named job '" + this.name + "', but name already taken.");
+      w.push(this);
+    }
+    return i !== undefined && _(i) && (this.fn = i, this.schedule()), this;
+  }
+  nextRun(e) {
+    let t = this._next(e);
+    return t ? this.applyDayOffset(t.getDate(false)) : null;
+  }
+  nextRuns(e, t) {
+    this._states.maxRuns !== undefined && e > this._states.maxRuns && (e = this._states.maxRuns);
+    let r = t || this._states.currentRun || undefined;
+    return this._enumerateRuns(e, r, "next");
+  }
+  previousRuns(e, t) {
+    return this._enumerateRuns(e, t || undefined, "previous");
+  }
+  _enumerateRuns(e, t, r) {
+    let n = [], i = t ? new m(t, this.getTz()) : null, a = r === "next" ? this._next : this._previous;
+    for (;e--; ) {
+      let o = a.call(this, i);
+      if (!o)
+        break;
+      let h = o.getDate(false);
+      n.push(this.applyDayOffset(h)), i = o;
+    }
+    return n;
+  }
+  match(e) {
+    if (this._states.once) {
+      let r = new m(e, this.getTz());
+      r.ms = 0;
+      let n = new m(this._states.once, this.getTz());
+      return n.ms = 0, r.getTime() === n.getTime();
+    }
+    let t = new m(e, this.getTz());
+    return t.ms = 0, t.match(this._states.pattern, this.options);
+  }
+  getPattern() {
+    if (!this._states.once)
+      return this._states.pattern ? this._states.pattern.pattern : undefined;
+  }
+  getOnce() {
+    return this._states.once ? this._states.once.getDate() : null;
+  }
+  isRunning() {
+    let e = this.nextRun(this._states.currentRun), t = !this._states.paused, r = this.fn !== undefined, n = !this._states.kill;
+    return t && r && n && e !== null;
+  }
+  isStopped() {
+    return this._states.kill;
+  }
+  isBusy() {
+    return this._states.blocking;
+  }
+  currentRun() {
+    return this._states.currentRun ? this._states.currentRun.getDate() : null;
+  }
+  previousRun() {
+    return this._states.previousRun ? this._states.previousRun.getDate() : null;
+  }
+  msToNext(e) {
+    let t = this._next(e);
+    return t ? e instanceof m || e instanceof Date ? t.getTime() - e.getTime() : t.getTime() - new m(e).getTime() : null;
+  }
+  stop() {
+    this._states.kill = true, this._states.currentTimeout && clearTimeout(this._states.currentTimeout);
+    let e = w.indexOf(this);
+    e >= 0 && w.splice(e, 1);
+  }
+  pause() {
+    return this._states.paused = true, !this._states.kill;
+  }
+  resume() {
+    return this._states.paused = false, !this._states.kill;
+  }
+  schedule(e) {
+    if (e && this.fn)
+      throw new Error("Cron: It is not allowed to schedule two functions using the same Croner instance.");
+    e && (this.fn = e);
+    let t = this.msToNext(), r = this.nextRun(this._states.currentRun);
+    return t == null || isNaN(t) || r === null ? this : (t > W && (t = W), this._states.currentTimeout = setTimeout(() => this._checkTrigger(r), t), this._states.currentTimeout && this.options.unref && x(this._states.currentTimeout), this);
+  }
+  async _trigger(e) {
+    this._states.blocking = true, this._states.currentRun = new m(undefined, this.getTz());
+    try {
+      if (this.options.catch)
+        try {
+          this.fn !== undefined && await this.fn(this, this.options.context);
+        } catch (t) {
+          if (p(this.options.catch))
+            try {
+              this.options.catch(t, this);
+            } catch {}
+        }
+      else
+        this.fn !== undefined && await this.fn(this, this.options.context);
+    } finally {
+      this._states.previousRun = new m(e, this.getTz()), this._states.blocking = false;
+    }
+  }
+  async trigger() {
+    await this._trigger();
+  }
+  runsLeft() {
+    return this._states.maxRuns;
+  }
+  _checkTrigger(e) {
+    let t = new Date, r = !this._states.paused && t.getTime() >= e.getTime(), n = this._states.blocking && this.options.protect;
+    r && !n ? (this._states.maxRuns !== undefined && this._states.maxRuns--, this._trigger()) : r && n && p(this.options.protect) && setTimeout(() => this.options.protect(this), 0), this.schedule();
+  }
+  _next(e) {
+    let t = !!(e || this._states.currentRun), r = false;
+    !e && this.options.startAt && this.options.interval && ([e, t] = this._calculatePreviousRun(e, t), r = !e), e = new m(e, this.getTz()), this.options.startAt && e && e.getTime() < this.options.startAt.getTime() && (e = this.options.startAt);
+    let n = this._states.once || new m(e, this.getTz());
+    return !r && n !== this._states.once && (n = n.increment(this._states.pattern, this.options, t)), this._states.once && this._states.once.getTime() <= e.getTime() || n === null || this._states.maxRuns !== undefined && this._states.maxRuns <= 0 || this._states.kill || this.options.stopAt && n.getTime() >= this.options.stopAt.getTime() ? null : n;
+  }
+  _previous(e) {
+    let t = new m(e, this.getTz());
+    this.options.stopAt && t.getTime() > this.options.stopAt.getTime() && (t = this.options.stopAt);
+    let r = new m(t, this.getTz());
+    return this._states.once ? this._states.once.getTime() < t.getTime() ? this._states.once : null : (r = r.decrement(this._states.pattern, this.options), r === null || this.options.startAt && r.getTime() < this.options.startAt.getTime() ? null : r);
+  }
+  _calculatePreviousRun(e, t) {
+    let r = new m(undefined, this.getTz()), n = e;
+    if (this.options.startAt.getTime() <= r.getTime()) {
+      n = this.options.startAt;
+      let i = n.getTime() + this.options.interval * 1000;
+      for (;i <= r.getTime(); )
+        n = new m(n, this.getTz()).increment(this._states.pattern, this.options, true), i = n.getTime() + this.options.interval * 1000;
+      t = true;
+    }
+    return n === null && (n = undefined), [n, t];
+  }
+};
+var init_croner = __esm(() => {
+  O = [1, 2, 4, 8, 16];
+  P = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  f = [["month", "year", 0], ["day", "month", -1], ["hour", "day", 0], ["minute", "hour", 0], ["second", "minute", 0]];
+  W = 30 * 1000;
+  w = [];
+});
+
+// ../core/src/tools/cron/index.ts
+function setSchedulerInstance2(scheduler) {
+  _scheduler2 = scheduler;
+}
+function getUserTimezone2() {
+  const db = getDb();
+  const user = db.query("SELECT timezone FROM users LIMIT 1").get();
+  return user?.timezone || "UTC";
+}
+function resolveBestChannel(userId, explicitChannel) {
+  const db = getDb();
+  const user = db.query("SELECT preferred_cron_channel FROM users WHERE id = ?").get(userId);
+  const activeChannels = db.query(`
+    SELECT ui.channel FROM user_identities ui
+    JOIN channels c ON c.id = ui.channel
+    WHERE ui.user_id = ? AND c.active = 1 AND c.status = 'connected'
+  `).all(userId);
+  const identities = activeChannels.length > 0 ? activeChannels : db.query("SELECT channel FROM user_identities WHERE user_id = ?").all(userId);
+  if (identities.length === 0) {
+    return "webchat";
+  }
+  let bestChannel = "";
+  if (explicitChannel && explicitChannel !== "system") {
+    if (identities.some((i) => i.channel === explicitChannel)) {
+      bestChannel = explicitChannel;
+    }
+  }
+  if (!bestChannel && user?.preferred_cron_channel && user.preferred_cron_channel !== "auto") {
+    if (identities.some((i) => i.channel === user.preferred_cron_channel)) {
+      bestChannel = user.preferred_cron_channel;
+    }
+  }
+  if (!bestChannel) {
+    const preferred = ["telegram", "discord", "slack", "whatsapp", "webchat"];
+    for (const p2 of preferred) {
+      if (identities.some((i) => i.channel === p2)) {
+        bestChannel = p2;
+        break;
+      }
+    }
+  }
+  if (!bestChannel) {
+    bestChannel = identities[0].channel;
+  }
+  return bestChannel;
+}
+function createTools2() {
+  return [
+    cronCreateTool,
+    cronListTool,
+    cronPauseTool,
+    cronResumeTool,
+    cronDeleteTool,
+    cronTriggerTool,
+    cronHistoryTool
+  ];
+}
+var log2, _scheduler2 = null, cronCreateTool, cronListTool, cronPauseTool, cronResumeTool, cronDeleteTool, cronTriggerTool, cronHistoryTool;
+var init_cron = __esm(() => {
+  init_sqlite();
+  init_logger();
+  init_croner();
+  log2 = logger.child("CronTools");
+  cronCreateTool = {
+    name: "cron.create",
+    description: "Create a new scheduled task. Use for recurring reminders, daily reports, automated checks. Spanish: crear tarea programada, agendar recordatorio, programar reporte",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Name for the scheduled task (e.g., 'daily-report', 'morning-reminder')" },
+        task_type: { type: "string", enum: ["recurring", "one_shot"], description: "Type: 'recurring' for cron-based, 'one_shot' for single execution" },
+        cron_expression: { type: "string", description: "Cron expression (5-7 fields) for recurring tasks. Example: '0 9 * * *' (daily at 9 AM)" },
+        fire_at: { type: "string", description: "ISO 8601 datetime for one_shot tasks. Example: '2026-04-01T09:00:00'" },
+        payload: { type: "object", description: "Payload with 'prompt' or 'message' field containing the task content" },
+        agent_id: { type: "string", description: "Target agent ID (optional, defaults to Coordinator)" },
+        tool_name: { type: "string", description: "Specific tool to execute (optional)" },
+        max_runs: { type: "number", description: "Maximum executions (optional, null = unlimited)" },
+        channel: { type: "string", description: "Notification channel (system, telegram, discord, whatsapp, cli)" }
+      },
+      required: ["name", "task_type"]
+    },
+    execute: async (params) => {
+      const db = getDb();
+      const timezone = getUserTimezone2();
+      const name = params.name;
+      const task_type = params.task_type;
+      const cron_expression = params.cron_expression;
+      const fire_at = params.fire_at;
+      const payload = params.payload;
+      const agent_id = params.agent_id;
+      const tool_name = params.tool_name;
+      const max_runs = params.max_runs;
+      const channel = params.channel || "system";
+      if (!name) {
+        return { ok: false, error: "Missing required field: name" };
+      }
+      if (!task_type) {
+        return { ok: false, error: "Missing required field: task_type (recurring or one_shot)" };
+      }
+      if (task_type === "recurring" && !cron_expression) {
+        return { ok: false, error: "recurring task requires cron_expression" };
+      }
+      if (task_type === "one_shot" && !fire_at) {
+        return { ok: false, error: "one_shot task requires fire_at" };
+      }
+      if (cron_expression) {
+        try {
+          new E(cron_expression);
+        } catch (err) {
+          return { ok: false, error: `Invalid cron expression: ${err.message}` };
+        }
+      }
+      if (fire_at) {
+        const fireAtDate = new Date(fire_at);
+        if (fireAtDate.getTime() <= Date.now()) {
+          return { ok: false, error: "fire_at must be in the future" };
+        }
+      }
+      if (payload && !payload._internal) {
+        const hasPrompt = !!(payload.prompt || payload.message);
+        if (!hasPrompt) {
+          return { ok: false, error: "Payload must contain 'prompt' or 'message' field" };
+        }
+      }
+      if (agent_id) {
+        const agent = db.query("SELECT id FROM agents WHERE id = ?").get(agent_id);
+        if (!agent) {
+          return { ok: false, error: `Agent not found: ${agent_id}` };
+        }
+      }
+      try {
+        if (_scheduler2) {
+          const result = _scheduler2.create({
+            name,
+            task_type,
+            cron_expression,
+            fire_at,
+            timezone,
+            payload: payload || { prompt: `Execute scheduled task: ${name}` },
+            agent_id: agent_id || null,
+            tool_name: tool_name || null,
+            max_runs: max_runs || null,
+            channel
+          });
+          log2.info(`[create] Task "${name}" created via scheduler: ${result.id}`);
+          return {
+            ok: true,
+            task_id: result.id,
+            next_run: result.nextRun,
+            message: `Task "${name}" scheduled. Next run: ${result.nextRun ? new Date(result.nextRun).toLocaleString() : "unknown"}`
+          };
+        } else {
+          const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+          const now = new Date().toISOString();
+          db.query(`
+          INSERT INTO scheduled_tasks (
+            id, name, task_type, cron_expression, fire_at, timezone, payload,
+            agent_id, tool_name, max_runs, channel, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, name, task_type, cron_expression || null, fire_at || null, timezone, JSON.stringify(payload || {}), agent_id || null, tool_name || null, max_runs || null, channel, now, now);
+          return {
+            ok: true,
+            task_id: id,
+            message: `Task "${name}" saved (scheduler not active)`
+          };
+        }
+      } catch (err) {
+        log2.error(`[create] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to create task: ${err.message}` };
+      }
+    }
+  };
+  cronListTool = {
+    name: "cron.list",
+    description: "List all scheduled tasks with their next execution times. Spanish: ver tareas programadas, listar cronograma",
+    parameters: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["active", "paused", "completed", "failed", "cancelled"], description: "Filter by status" },
+        task_type: { type: "string", enum: ["recurring", "one_shot"], description: "Filter by type" }
+      }
+    },
+    execute: async (params) => {
+      const db = getDb();
+      const status = params.status;
+      const task_type = params.task_type;
+      try {
+        let query = "SELECT * FROM scheduled_tasks WHERE 1=1";
+        const args = [];
+        if (status) {
+          query += " AND status = ?";
+          args.push(status);
+        }
+        if (task_type) {
+          query += " AND task_type = ?";
+          args.push(task_type);
+        }
+        query += " ORDER BY next_run_at ASC";
+        const tasks = db.query(query).all(...args);
+        return {
+          ok: true,
+          tasks: tasks.map((t) => ({
+            id: t.id,
+            name: t.name,
+            type: t.task_type,
+            status: t.status,
+            cron_expression: t.cron_expression,
+            fire_at: t.fire_at,
+            next_run: t.next_run_at,
+            last_run: t.last_run_at,
+            run_count: t.run_count,
+            channel: t.channel
+          })),
+          count: tasks.length
+        };
+      } catch (err) {
+        log2.error(`[list] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to list tasks: ${err.message}` };
+      }
+    }
+  };
+  cronPauseTool = {
+    name: "cron.pause",
+    description: "Pause a scheduled task. Spanish: pausar tarea programada, detener temporalmente",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "ID of the task to pause" }
+      },
+      required: ["task_id"]
+    },
+    execute: async (params) => {
+      const task_id = params.task_id;
+      if (!task_id) {
+        return { ok: false, error: "Missing required field: task_id" };
+      }
+      try {
+        if (_scheduler2) {
+          const success = _scheduler2.pause(task_id);
+          if (success) {
+            return { ok: true, message: `Task "${task_id}" paused` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found or already paused` };
+          }
+        } else {
+          const db = getDb();
+          const result = db.query("UPDATE scheduled_tasks SET status = 'paused' WHERE id = ?").run(task_id);
+          if (result.changes > 0) {
+            return { ok: true, message: `Task "${task_id}" paused (scheduler not active)` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found` };
+          }
+        }
+      } catch (err) {
+        log2.error(`[pause] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to pause task: ${err.message}` };
+      }
+    }
+  };
+  cronResumeTool = {
+    name: "cron.resume",
+    description: "Resume a paused scheduled task. Spanish: reanudar tarea programada, continuar",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "ID of the task to resume" }
+      },
+      required: ["task_id"]
+    },
+    execute: async (params) => {
+      const task_id = params.task_id;
+      if (!task_id) {
+        return { ok: false, error: "Missing required field: task_id" };
+      }
+      try {
+        if (_scheduler2) {
+          const success = _scheduler2.resume(task_id);
+          if (success) {
+            return { ok: true, message: `Task "${task_id}" resumed` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found or already active` };
+          }
+        } else {
+          const db = getDb();
+          const result = db.query("UPDATE scheduled_tasks SET status = 'active' WHERE id = ?").run(task_id);
+          if (result.changes > 0) {
+            return { ok: true, message: `Task "${task_id}" resumed (scheduler not active)` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found` };
+          }
+        }
+      } catch (err) {
+        log2.error(`[resume] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to resume task: ${err.message}` };
+      }
+    }
+  };
+  cronDeleteTool = {
+    name: "cron.delete",
+    description: "Delete a scheduled task permanently. Spanish: eliminar tarea programada, cancelar recordatorio",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "ID of the task to delete" }
+      },
+      required: ["task_id"]
+    },
+    execute: async (params) => {
+      const task_id = params.task_id;
+      if (!task_id) {
+        return { ok: false, error: "Missing required field: task_id" };
+      }
+      try {
+        if (_scheduler2) {
+          const success = _scheduler2.delete(task_id);
+          if (success) {
+            return { ok: true, message: `Task "${task_id}" deleted` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found` };
+          }
+        } else {
+          const db = getDb();
+          const result = db.query("DELETE FROM scheduled_tasks WHERE id = ?").run(task_id);
+          if (result.changes > 0) {
+            return { ok: true, message: `Task "${task_id}" deleted (scheduler not active)` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found` };
+          }
+        }
+      } catch (err) {
+        log2.error(`[delete] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to delete task: ${err.message}` };
+      }
+    }
+  };
+  cronTriggerTool = {
+    name: "cron.trigger",
+    description: "Manually trigger a scheduled task execution immediately. Spanish: ejecutar tarea ahora, forzar ejecuci\xF3n",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "ID of the task to trigger" }
+      },
+      required: ["task_id"]
+    },
+    execute: async (params) => {
+      const task_id = params.task_id;
+      if (!task_id) {
+        return { ok: false, error: "Missing required field: task_id" };
+      }
+      try {
+        if (_scheduler2) {
+          const success = _scheduler2.trigger(task_id);
+          if (success) {
+            return { ok: true, message: `Task "${task_id}" triggered` };
+          } else {
+            return { ok: false, error: `Task "${task_id}" not found or not active` };
+          }
+        } else {
+          return { ok: false, error: "Scheduler not active - cannot trigger tasks" };
+        }
+      } catch (err) {
+        log2.error(`[trigger] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to trigger task: ${err.message}` };
+      }
+    }
+  };
+  cronHistoryTool = {
+    name: "cron.history",
+    description: "Get execution history for a scheduled task. Spanish: historial de ejecuciones, logs de tarea",
+    parameters: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "ID of the task" },
+        limit: { type: "number", description: "Maximum number of records (default: 10)" }
+      },
+      required: ["task_id"]
+    },
+    execute: async (params) => {
+      const task_id = params.task_id;
+      const limit = params.limit || 10;
+      if (!task_id) {
+        return { ok: false, error: "Missing required field: task_id" };
+      }
+      try {
+        const db = getDb();
+        const runs = db.query(`
+        SELECT * FROM task_runs
+        WHERE task_id = ?
+        ORDER BY started_at DESC
+        LIMIT ?
+      `).all(task_id, limit);
+        return {
+          ok: true,
+          history: runs.map((r) => ({
+            id: r.id,
+            status: r.status,
+            started_at: r.started_at,
+            finished_at: r.finished_at,
+            duration_ms: r.duration_ms,
+            error_message: r.error_message
+          })),
+          count: runs.length
+        };
+      } catch (err) {
+        log2.error(`[history] Failed: ${err.message}`);
+        return { ok: false, error: `Failed to get history: ${err.message}` };
+      }
+    }
+  };
+});
+
+// ../core/src/tools/schedule.ts
+init_sqlite();
+init_logger();
+init_croner();
+var log = logger.child("ScheduleTools");
+var _scheduler = null;
+function setSchedulerInstance(scheduler) {
+  _scheduler = scheduler;
+}
+function getUserTimezone() {
+  const db = getDb();
+  const user = db.query("SELECT timezone FROM users LIMIT 1").get();
+  return user?.timezone || "UTC";
+}
+var scheduleCreateTool = {
+  name: "hive.schedule.create",
+  description: "Create a new scheduled task. Use for recurring reminders, daily reports, automated checks. Spanish: crear tarea programada, agendar recordatorio, programar reporte",
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Name for the scheduled task (e.g., 'daily-report', 'morning-reminder')" },
+      task_type: { type: "string", enum: ["recurring", "one_shot"], description: "Type: 'recurring' for cron-based, 'one_shot' for single execution" },
+      cron_expression: { type: "string", description: "Cron expression (5-7 fields) for recurring tasks. Example: '0 9 * * *' (daily at 9 AM)" },
+      fire_at: { type: "string", description: "ISO 8601 datetime for one_shot tasks. Example: '2026-04-01T09:00:00'" },
+      payload: { type: "object", description: "Payload with 'prompt' or 'message' field containing the task content" },
+      agent_id: { type: "string", description: "Target agent ID (optional, defaults to Coordinator)" },
+      tool_name: { type: "string", description: "Specific tool to execute (optional)" },
+      max_runs: { type: "number", description: "Maximum executions (optional, null = unlimited)" },
+      channel: { type: "string", description: "Notification channel (system, telegram, discord, whatsapp, cli)" }
+    },
+    required: ["name", "task_type"]
+  },
+  execute: async (params) => {
+    const db = getDb();
+    const timezone = getUserTimezone();
+    const name = params.name;
+    const task_type = params.task_type;
+    const cron_expression = params.cron_expression;
+    const fire_at = params.fire_at;
+    const payload = params.payload;
+    const agent_id = params.agent_id;
+    const tool_name = params.tool_name;
+    const max_runs = params.max_runs;
+    const channel = params.channel || "system";
+    if (!name) {
+      return { ok: false, error: "Missing required field: name" };
+    }
+    if (!task_type) {
+      return { ok: false, error: "Missing required field: task_type (recurring or one_shot)" };
+    }
+    if (task_type === "recurring" && !cron_expression) {
+      return { ok: false, error: "recurring task requires cron_expression" };
+    }
+    if (task_type === "one_shot" && !fire_at) {
+      return { ok: false, error: "one_shot task requires fire_at" };
+    }
+    if (cron_expression) {
+      try {
+        new E(cron_expression);
+      } catch (err) {
+        return { ok: false, error: `Invalid cron expression: ${err.message}` };
+      }
+    }
+    if (fire_at) {
+      const fireAtDate = new Date(fire_at);
+      if (fireAtDate.getTime() <= Date.now()) {
+        return { ok: false, error: "fire_at must be in the future" };
+      }
+    }
+    if (payload && !payload._internal) {
+      const hasPrompt = !!(payload.prompt || payload.message);
+      if (!hasPrompt) {
+        return { ok: false, error: "Payload must contain 'prompt' or 'message' field" };
+      }
+    }
+    if (agent_id) {
+      const agent = db.query("SELECT id FROM agents WHERE id = ?").get(agent_id);
+      if (!agent) {
+        return { ok: false, error: `Agent not found: ${agent_id}` };
+      }
+    }
+    try {
+      if (_scheduler) {
+        const result = _scheduler.create({
+          name,
+          task_type,
+          cron_expression,
+          fire_at,
+          timezone,
+          payload: payload || { prompt: `Execute scheduled task: ${name}` },
+          agent_id: agent_id || null,
+          tool_name: tool_name || null,
+          max_runs: max_runs || null,
+          channel
+        });
+        log.info(`[create] Task "${name}" created via scheduler: ${result.id}`);
+        return {
+          ok: true,
+          task_id: result.id,
+          next_run: result.nextRun,
+          message: `Task "${name}" scheduled. Next run: ${result.nextRun ? new Date(result.nextRun).toLocaleString() : "unknown"}`
+        };
+      } else {
+        const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+        const now = new Date().toISOString();
+        db.query(`
+          INSERT INTO scheduled_tasks (
+            id, name, task_type, cron_expression, fire_at, timezone, payload,
+            agent_id, tool_name, max_runs, channel, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, name, task_type, cron_expression || null, fire_at || null, timezone, JSON.stringify(payload || {}), agent_id || null, tool_name || null, max_runs || null, channel, now, now);
+        return {
+          ok: true,
+          task_id: id,
+          message: `Task "${name}" saved (scheduler not active)`
+        };
+      }
+    } catch (err) {
+      log.error(`[create] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to create task: ${err.message}` };
+    }
+  }
+};
+var scheduleListTool = {
+  name: "hive.schedule.list",
+  description: "List all scheduled tasks with their next execution times. Spanish: ver tareas programadas, listar cronograma",
+  parameters: {
+    type: "object",
+    properties: {
+      status: { type: "string", enum: ["active", "paused", "completed", "failed", "cancelled"], description: "Filter by status" },
+      task_type: { type: "string", enum: ["recurring", "one_shot"], description: "Filter by type" }
+    }
+  },
+  execute: async (params) => {
+    const db = getDb();
+    const status = params.status;
+    const task_type = params.task_type;
+    try {
+      let query = "SELECT * FROM scheduled_tasks WHERE 1=1";
+      const args = [];
+      if (status) {
+        query += " AND status = ?";
+        args.push(status);
+      }
+      if (task_type) {
+        query += " AND task_type = ?";
+        args.push(task_type);
+      }
+      query += " ORDER BY next_run_at ASC";
+      const tasks = db.query(query).all(...args);
+      return {
+        ok: true,
+        tasks: tasks.map((t) => ({
+          id: t.id,
+          name: t.name,
+          type: t.task_type,
+          status: t.status,
+          cron_expression: t.cron_expression,
+          fire_at: t.fire_at,
+          next_run: t.next_run_at,
+          last_run: t.last_run_at,
+          run_count: t.run_count,
+          channel: t.channel
+        })),
+        count: tasks.length
+      };
+    } catch (err) {
+      log.error(`[list] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to list tasks: ${err.message}` };
+    }
+  }
+};
+var schedulePauseTool = {
+  name: "hive.schedule.pause",
+  description: "Pause a scheduled task. Spanish: pausar tarea programada, detener temporalmente",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "ID of the task to pause" }
+    },
+    required: ["task_id"]
+  },
+  execute: async (params) => {
+    const task_id = params.task_id;
+    if (!task_id) {
+      return { ok: false, error: "Missing required field: task_id" };
+    }
+    try {
+      if (_scheduler) {
+        const success = _scheduler.pause(task_id);
+        if (success) {
+          return { ok: true, message: `Task "${task_id}" paused` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found or already paused` };
+        }
+      } else {
+        const db = getDb();
+        const result = db.query("UPDATE scheduled_tasks SET status = 'paused' WHERE id = ?").run(task_id);
+        if (result.changes > 0) {
+          return { ok: true, message: `Task "${task_id}" paused (scheduler not active)` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found` };
+        }
+      }
+    } catch (err) {
+      log.error(`[pause] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to pause task: ${err.message}` };
+    }
+  }
+};
+var scheduleResumeTool = {
+  name: "hive.schedule.resume",
+  description: "Resume a paused scheduled task. Spanish: reanudar tarea programada, continuar",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "ID of the task to resume" }
+    },
+    required: ["task_id"]
+  },
+  execute: async (params) => {
+    const task_id = params.task_id;
+    if (!task_id) {
+      return { ok: false, error: "Missing required field: task_id" };
+    }
+    try {
+      if (_scheduler) {
+        const success = _scheduler.resume(task_id);
+        if (success) {
+          return { ok: true, message: `Task "${task_id}" resumed` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found or already active` };
+        }
+      } else {
+        const db = getDb();
+        const result = db.query("UPDATE scheduled_tasks SET status = 'active' WHERE id = ?").run(task_id);
+        if (result.changes > 0) {
+          return { ok: true, message: `Task "${task_id}" resumed (scheduler not active)` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found` };
+        }
+      }
+    } catch (err) {
+      log.error(`[resume] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to resume task: ${err.message}` };
+    }
+  }
+};
+var scheduleDeleteTool = {
+  name: "hive.schedule.delete",
+  description: "Delete a scheduled task permanently. Spanish: eliminar tarea programada, cancelar recordatorio",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "ID of the task to delete" }
+    },
+    required: ["task_id"]
+  },
+  execute: async (params) => {
+    const task_id = params.task_id;
+    if (!task_id) {
+      return { ok: false, error: "Missing required field: task_id" };
+    }
+    try {
+      if (_scheduler) {
+        const success = _scheduler.delete(task_id);
+        if (success) {
+          return { ok: true, message: `Task "${task_id}" deleted` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found` };
+        }
+      } else {
+        const db = getDb();
+        const result = db.query("DELETE FROM scheduled_tasks WHERE id = ?").run(task_id);
+        if (result.changes > 0) {
+          return { ok: true, message: `Task "${task_id}" deleted (scheduler not active)` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found` };
+        }
+      }
+    } catch (err) {
+      log.error(`[delete] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to delete task: ${err.message}` };
+    }
+  }
+};
+var scheduleTriggerTool = {
+  name: "hive.schedule.trigger",
+  description: "Manually trigger a scheduled task execution immediately. Spanish: ejecutar tarea ahora, forzar ejecuci\xF3n",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "ID of the task to trigger" }
+    },
+    required: ["task_id"]
+  },
+  execute: async (params) => {
+    const task_id = params.task_id;
+    if (!task_id) {
+      return { ok: false, error: "Missing required field: task_id" };
+    }
+    try {
+      if (_scheduler) {
+        const success = _scheduler.trigger(task_id);
+        if (success) {
+          return { ok: true, message: `Task "${task_id}" triggered` };
+        } else {
+          return { ok: false, error: `Task "${task_id}" not found or not active` };
+        }
+      } else {
+        return { ok: false, error: "Scheduler not active - cannot trigger tasks" };
+      }
+    } catch (err) {
+      log.error(`[trigger] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to trigger task: ${err.message}` };
+    }
+  }
+};
+var scheduleHistoryTool = {
+  name: "hive.schedule.history",
+  description: "Get execution history for a scheduled task. Spanish: historial de ejecuciones, logs de tarea",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "ID of the task" },
+      limit: { type: "number", description: "Maximum number of records (default: 10)" }
+    },
+    required: ["task_id"]
+  },
+  execute: async (params) => {
+    const task_id = params.task_id;
+    const limit = params.limit || 10;
+    if (!task_id) {
+      return { ok: false, error: "Missing required field: task_id" };
+    }
+    try {
+      const db = getDb();
+      const runs = db.query(`
+        SELECT * FROM task_runs 
+        WHERE task_id = ? 
+        ORDER BY started_at DESC 
+        LIMIT ?
+      `).all(task_id, limit);
+      return {
+        ok: true,
+        history: runs.map((r) => ({
+          id: r.id,
+          status: r.status,
+          started_at: r.started_at,
+          finished_at: r.finished_at,
+          duration_ms: r.duration_ms,
+          error_message: r.error_message
+        })),
+        count: runs.length
+      };
+    } catch (err) {
+      log.error(`[history] Failed: ${err.message}`);
+      return { ok: false, error: `Failed to get history: ${err.message}` };
+    }
+  }
+};
+function createTools() {
+  return [
+    scheduleCreateTool,
+    scheduleListTool,
+    schedulePauseTool,
+    scheduleResumeTool,
+    scheduleDeleteTool,
+    scheduleTriggerTool,
+    scheduleHistoryTool
+  ];
+}
+
 // src/cron/index.ts
-import {
-  scheduleCreateTool,
-  scheduleListTool,
-  schedulePauseTool,
-  scheduleResumeTool,
-  scheduleDeleteTool,
-  scheduleTriggerTool,
-  scheduleHistoryTool,
-  createTools,
-  setSchedulerInstance
-} from "@johpaz/hive-agents-core/tools/schedule";
-import {
-  cronAddTool,
-  cronListTool,
-  cronEditTool,
-  cronRemoveTool,
-  createTools as createTools2,
-  initCronScheduler,
-  resolveBestChannel
-} from "@johpaz/hive-agents-core/tools/cron";
+init_cron();
 export {
   setSchedulerInstance,
   scheduleTriggerTool,
@@ -30,11 +3250,13 @@ export {
   scheduleDeleteTool,
   scheduleCreateTool,
   resolveBestChannel,
-  initCronScheduler,
-  cronRemoveTool,
+  cronTriggerTool,
+  cronResumeTool,
+  cronPauseTool,
   cronListTool,
-  cronEditTool,
-  cronAddTool,
+  cronHistoryTool,
+  cronDeleteTool,
+  cronCreateTool,
   createTools as createScheduleTools,
   createTools2 as createCronTools
 };