titan-agent 2026.4.0

package/dist/gateway/server.js

@@ -0,0 +1,4462 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var TITAN_VERSION, TITAN_NAME, TITAN_ASCII_LOGO, TITAN_HOME, TITAN_CONFIG_PATH, TITAN_DB_PATH, TITAN_WORKSPACE, TITAN_SKILLS_DIR, TITAN_LOGS_DIR, TITAN_MEMORY_DIR, AGENTS_MD, SOUL_MD, TOOLS_MD, DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, DEFAULT_WEB_PORT, DEFAULT_MODEL, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, MAX_CONTEXT_MESSAGES, SESSION_TIMEOUT_MS, DEFAULT_SANDBOX_MODE, ALLOWED_TOOLS_DEFAULT;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    TITAN_VERSION = "2026.4.0";
+    TITAN_NAME = "TITAN";
+    TITAN_ASCII_LOGO = `
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                    \u2551
+\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557         \u2551
+\u2551   \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551         \u2551
+\u2551      \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D         \u2551
+\u2551                                                    \u2551
+\u2551   The Intelligent Task Automation Network          \u2551
+\u2551   v${TITAN_VERSION}                                          \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`;
+    TITAN_HOME = join(homedir(), ".titan");
+    TITAN_CONFIG_PATH = join(TITAN_HOME, "titan.json");
+    TITAN_DB_PATH = join(TITAN_HOME, "titan.db");
+    TITAN_WORKSPACE = join(TITAN_HOME, "workspace");
+    TITAN_SKILLS_DIR = join(TITAN_WORKSPACE, "skills");
+    TITAN_LOGS_DIR = join(TITAN_HOME, "logs");
+    TITAN_MEMORY_DIR = join(TITAN_HOME, "memory");
+    AGENTS_MD = join(TITAN_WORKSPACE, "AGENTS.md");
+    SOUL_MD = join(TITAN_WORKSPACE, "SOUL.md");
+    TOOLS_MD = join(TITAN_WORKSPACE, "TOOLS.md");
+    DEFAULT_GATEWAY_HOST = "127.0.0.1";
+    DEFAULT_GATEWAY_PORT = 18789;
+    DEFAULT_WEB_PORT = 18790;
+    DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514";
+    DEFAULT_MAX_TOKENS = 8192;
+    DEFAULT_TEMPERATURE = 0.7;
+    MAX_CONTEXT_MESSAGES = 50;
+    SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+    DEFAULT_SANDBOX_MODE = "host";
+    ALLOWED_TOOLS_DEFAULT = [
+      "shell",
+      "read_file",
+      "write_file",
+      "edit_file",
+      "list_dir",
+      "web_search",
+      "browser",
+      "cron",
+      "webhook",
+      "email",
+      "memory"
+    ];
+  }
+});
+
+// src/utils/helpers.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+var init_helpers = __esm({
+  "src/utils/helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema, ChannelConfigSchema, SecurityConfigSchema, GatewayConfigSchema, AgentConfigSchema, TitanConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    init_constants();
+    ProviderConfigSchema = z.object({
+      apiKey: z.string().optional(),
+      baseUrl: z.string().optional(),
+      model: z.string().optional(),
+      maxTokens: z.number().optional(),
+      temperature: z.number().min(0).max(2).optional()
+    });
+    ChannelConfigSchema = z.object({
+      enabled: z.boolean().default(false),
+      token: z.string().optional(),
+      apiKey: z.string().optional(),
+      allowFrom: z.array(z.string()).default([]),
+      dmPolicy: z.enum(["pairing", "open", "closed"]).default("pairing")
+    });
+    SecurityConfigSchema = z.object({
+      sandboxMode: z.enum(["host", "docker", "none"]).default(DEFAULT_SANDBOX_MODE),
+      allowedTools: z.array(z.string()).default(ALLOWED_TOOLS_DEFAULT),
+      deniedTools: z.array(z.string()).default([]),
+      maxConcurrentTasks: z.number().default(5),
+      commandTimeout: z.number().default(3e4),
+      fileSystemAllowlist: z.array(z.string()).default([]),
+      networkAllowlist: z.array(z.string()).default(["*"]),
+      shield: z.object({
+        enabled: z.boolean().default(true),
+        mode: z.enum(["standard", "strict"]).default("strict")
+      }).default({})
+    });
+    GatewayConfigSchema = z.object({
+      host: z.string().default(DEFAULT_GATEWAY_HOST),
+      port: z.number().default(DEFAULT_GATEWAY_PORT),
+      webPort: z.number().default(DEFAULT_WEB_PORT),
+      auth: z.object({
+        mode: z.enum(["none", "token", "password"]).default("token"),
+        token: z.string().optional(),
+        password: z.string().optional()
+      }).default({})
+    });
+    AgentConfigSchema = z.object({
+      model: z.string().default(DEFAULT_MODEL),
+      maxTokens: z.number().default(DEFAULT_MAX_TOKENS),
+      temperature: z.number().default(DEFAULT_TEMPERATURE),
+      systemPrompt: z.string().optional(),
+      workspace: z.string().optional(),
+      thinkingMode: z.enum(["off", "low", "medium", "high"]).default("medium")
+    });
+    TitanConfigSchema = z.object({
+      agent: AgentConfigSchema.default({}),
+      providers: z.object({
+        anthropic: ProviderConfigSchema.default({}),
+        openai: ProviderConfigSchema.default({}),
+        google: ProviderConfigSchema.default({}),
+        ollama: ProviderConfigSchema.default({})
+      }).default({}),
+      channels: z.object({
+        discord: ChannelConfigSchema.default({}),
+        telegram: ChannelConfigSchema.default({}),
+        slack: ChannelConfigSchema.default({}),
+        whatsapp: ChannelConfigSchema.default({}),
+        webchat: ChannelConfigSchema.default({}),
+        googlechat: ChannelConfigSchema.default({}),
+        matrix: ChannelConfigSchema.default({}),
+        signal: ChannelConfigSchema.default({}),
+        msteams: ChannelConfigSchema.default({}),
+        bluebubbles: ChannelConfigSchema.default({})
+      }).default({}),
+      gateway: GatewayConfigSchema.default({}),
+      security: SecurityConfigSchema.default({}),
+      memory: z.object({
+        enabled: z.boolean().default(true),
+        maxHistoryMessages: z.number().default(50),
+        vectorSearchEnabled: z.boolean().default(false)
+      }).default({}),
+      skills: z.object({
+        enabled: z.boolean().default(true),
+        autoDiscover: z.boolean().default(true),
+        marketplace: z.boolean().default(false)
+      }).default({}),
+      logging: z.object({
+        level: z.enum(["debug", "info", "warn", "error", "silent"]).default("info"),
+        file: z.boolean().default(true)
+      }).default({}),
+      autonomy: z.object({
+        /** autonomous = full auto, supervised = asks for dangerous ops, locked = asks for everything */
+        mode: z.enum(["autonomous", "supervised", "locked"]).default("supervised"),
+        /** Auto-approve moderate-risk tools in main session (cli/webchat) */
+        autoApproveMainSession: z.boolean().default(true),
+        /** Timeout for HITL approval requests (ms). Auto-deny after timeout. */
+        approvalTimeoutMs: z.number().default(6e4),
+        /** Notify user of auto-approved actions */
+        notifyOnAutoApprove: z.boolean().default(true)
+      }).default({})
+    });
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function formatTimestamp() {
+  return chalk.gray((/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19));
+}
+function log(level, component, message, ...args) {
+  if (level < currentLevel) return;
+  const prefix = `${formatTimestamp()} ${LEVEL_LABELS[level]} ${chalk.blue(`[${component}]`)}`;
+  console.log(`${prefix} ${message}`, ...args);
+}
+var LEVEL_LABELS, currentLevel, logger, logger_default;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    LEVEL_LABELS = {
+      [0 /* DEBUG */]: chalk.gray("DEBUG"),
+      [1 /* INFO */]: chalk.cyan("INFO "),
+      [2 /* WARN */]: chalk.yellow("WARN "),
+      [3 /* ERROR */]: chalk.red("ERROR"),
+      [4 /* SILENT */]: ""
+    };
+    currentLevel = 1 /* INFO */;
+    logger = {
+      debug: (component, msg, ...args) => log(0 /* DEBUG */, component, msg, ...args),
+      info: (component, msg, ...args) => log(1 /* INFO */, component, msg, ...args),
+      warn: (component, msg, ...args) => log(2 /* WARN */, component, msg, ...args),
+      error: (component, msg, ...args) => log(3 /* ERROR */, component, msg, ...args)
+    };
+    logger_default = logger;
+  }
+});
+
+// src/config/config.ts
+import { existsSync as existsSync2 } from "fs";
+function getDefaultConfig() {
+  return TitanConfigSchema.parse({});
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  ensureDir(TITAN_HOME);
+  let rawConfig = {};
+  if (existsSync2(TITAN_CONFIG_PATH)) {
+    const loaded = readJsonFile(TITAN_CONFIG_PATH);
+    if (loaded) {
+      rawConfig = loaded;
+      logger_default.debug(COMPONENT, `Loaded config from ${TITAN_CONFIG_PATH}`);
+    } else {
+      logger_default.warn(COMPONENT, `Failed to parse config at ${TITAN_CONFIG_PATH}, using defaults`);
+    }
+  } else {
+    logger_default.info(COMPONENT, "No config file found, using defaults");
+  }
+  applyEnvOverrides(rawConfig);
+  const result = TitanConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    logger_default.warn(COMPONENT, "Config validation issues, using defaults for invalid fields");
+    logger_default.debug(COMPONENT, result.error.message);
+    cachedConfig = getDefaultConfig();
+  } else {
+    cachedConfig = result.data;
+  }
+  return cachedConfig;
+}
+function applyEnvOverrides(config) {
+  const envMap = {
+    TITAN_MODEL: (val) => setNested(config, "agent.model", val),
+    TITAN_GATEWAY_PORT: (val) => setNested(config, "gateway.port", parseInt(val, 10)),
+    TITAN_GATEWAY_HOST: (val) => setNested(config, "gateway.host", val),
+    TITAN_LOG_LEVEL: (val) => setNested(config, "logging.level", val),
+    ANTHROPIC_API_KEY: (val) => setNested(config, "providers.anthropic.apiKey", val),
+    OPENAI_API_KEY: (val) => setNested(config, "providers.openai.apiKey", val),
+    GOOGLE_API_KEY: (val) => setNested(config, "providers.google.apiKey", val),
+    OLLAMA_BASE_URL: (val) => setNested(config, "providers.ollama.baseUrl", val),
+    DISCORD_TOKEN: (val) => setNested(config, "channels.discord.token", val),
+    TELEGRAM_TOKEN: (val) => setNested(config, "channels.telegram.token", val),
+    SLACK_TOKEN: (val) => setNested(config, "channels.slack.token", val)
+  };
+  for (const [envKey, setter] of Object.entries(envMap)) {
+    const val = process.env[envKey];
+    if (val) {
+      setter(val);
+      logger_default.debug(COMPONENT, `Applied env override: ${envKey}`);
+    }
+  }
+}
+function setNested(obj, path2, value) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!current[parts[i]] || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+var COMPONENT, cachedConfig;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_schema();
+    init_logger();
+    COMPONENT = "Config";
+    cachedConfig = null;
+  }
+});
+
+// src/security/encryption.ts
+var encryption_exports = {};
+__export(encryption_exports, {
+  decrypt: () => decrypt,
+  encrypt: () => encrypt,
+  generateKey: () => generateKey
+});
+import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
+function generateKey() {
+  return randomBytes(32);
+}
+function encrypt(text, key) {
+  try {
+    const keyBuffer = typeof key === "string" ? Buffer.from(key, "hex") : key;
+    if (keyBuffer.length !== 32) {
+      throw new Error("Encryption key must be exactly 32 bytes (256 bits).");
+    }
+    const iv = randomBytes(16);
+    const cipher = createCipheriv(ALGORITHM, keyBuffer, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag().toString("hex");
+    return {
+      iv: iv.toString("hex"),
+      authTag,
+      data: encrypted
+    };
+  } catch (e) {
+    logger_default.error(COMPONENT2, `Encryption failed: ${e.message}`);
+    throw new Error("Failed to encrypt session data.");
+  }
+}
+function decrypt(payload, key) {
+  try {
+    const keyBuffer = typeof key === "string" ? Buffer.from(key, "hex") : key;
+    if (keyBuffer.length !== 32) {
+      throw new Error("Decryption key must be exactly 32 bytes (256 bits).");
+    }
+    const decipher = createDecipheriv(ALGORITHM, keyBuffer, Buffer.from(payload.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(payload.authTag, "hex"));
+    let decrypted = decipher.update(payload.data, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch (e) {
+    logger_default.error(COMPONENT2, `Decryption failed: ${e.message}`);
+    throw new Error("Failed to decrypt session data. Invalid key or corrupted payload.");
+  }
+}
+var COMPONENT2, ALGORITHM;
+var init_encryption = __esm({
+  "src/security/encryption.ts"() {
+    "use strict";
+    init_logger();
+    COMPONENT2 = "Encryption";
+    ALGORITHM = "aes-256-gcm";
+  }
+});
+
+// src/memory/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function getDefaultStore() {
+  return {
+    conversations: [],
+    memories: [],
+    sessions: [],
+    usageStats: [],
+    cronJobs: [],
+    skillsInstalled: []
+  };
+}
+function loadStore() {
+  if (store) return store;
+  ensureDir(TITAN_HOME);
+  if (existsSync3(DB_FILE)) {
+    try {
+      const raw = readFileSync2(DB_FILE, "utf-8");
+      store = JSON.parse(raw);
+      store.conversations = store.conversations || [];
+      store.memories = store.memories || [];
+      store.sessions = store.sessions || [];
+      store.usageStats = store.usageStats || [];
+      store.cronJobs = store.cronJobs || [];
+      store.skillsInstalled = store.skillsInstalled || [];
+    } catch {
+      logger_default.warn(COMPONENT3, "Could not load data store, creating fresh one");
+      store = getDefaultStore();
+    }
+  } else {
+    store = getDefaultStore();
+  }
+  return store;
+}
+function saveStore() {
+  if (!store) return;
+  ensureDir(TITAN_HOME);
+  try {
+    writeFileSync2(DB_FILE, JSON.stringify(store, null, 2), "utf-8");
+  } catch (e) {
+    logger_default.error(COMPONENT3, `Failed to save data: ${e.message}`);
+  }
+}
+function debouncedSave() {
+  if (saveTimeout) clearTimeout(saveTimeout);
+  saveTimeout = setTimeout(saveStore, 1e3);
+}
+function initMemory() {
+  loadStore();
+  logger_default.info(COMPONENT3, "Memory system initialized");
+}
+function getDb() {
+  return loadStore();
+}
+function saveMessage(message, e2eKey) {
+  const s = loadStore();
+  let content = message.content;
+  let isEncrypted = false;
+  if (e2eKey) {
+    try {
+      const payload = encrypt(message.content, Buffer.from(e2eKey, "base64"));
+      content = JSON.stringify(payload);
+      isEncrypted = true;
+    } catch (e) {
+      logger_default.error(COMPONENT3, `Failed to encrypt message for storage`);
+      content = "[ENCRYPTION FAILED] " + content;
+    }
+  }
+  s.conversations.push({
+    ...message,
+    content,
+    isEncrypted,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (s.conversations.length > 5e3) {
+    s.conversations = s.conversations.slice(-5e3);
+  }
+  debouncedSave();
+}
+function getHistory(sessionId, limit = 50, e2eKey) {
+  const s = loadStore();
+  const rawHistory = s.conversations.filter((m) => m.sessionId === sessionId).slice(-limit);
+  if (!e2eKey) {
+    return rawHistory;
+  }
+  return rawHistory.map((m) => {
+    if (m.isEncrypted) {
+      try {
+        const payload = JSON.parse(m.content);
+        return {
+          ...m,
+          content: decrypt(payload, Buffer.from(e2eKey, "base64"))
+        };
+      } catch (e) {
+        logger_default.error(COMPONENT3, `Failed to decrypt message ${m.id}`);
+        return { ...m, content: "[DECRYPTION FAILED]" };
+      }
+    }
+    return m;
+  });
+}
+function rememberFact(category, key, value, metadata) {
+  const s = loadStore();
+  const id = `${category}:${key}`;
+  const existingIdx = s.memories.findIndex((m) => m.id === id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existingIdx >= 0) {
+    s.memories[existingIdx].value = value;
+    s.memories[existingIdx].metadata = metadata ? JSON.stringify(metadata) : void 0;
+    s.memories[existingIdx].updatedAt = now;
+  } else {
+    s.memories.push({
+      id,
+      category,
+      key,
+      value,
+      metadata: metadata ? JSON.stringify(metadata) : void 0,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  debouncedSave();
+}
+function recallFact(category, key) {
+  const s = loadStore();
+  const entry = s.memories.find((m) => m.category === category && m.key === key);
+  return entry?.value || null;
+}
+function searchMemories(category, query) {
+  const s = loadStore();
+  let results = s.memories;
+  if (category) {
+    results = results.filter((m) => m.category === category);
+  }
+  if (query) {
+    const q = query.toLowerCase();
+    results = results.filter(
+      (m) => m.key.toLowerCase().includes(q) || m.value.toLowerCase().includes(q)
+    );
+  }
+  return results.slice(-50).map((m) => ({ key: m.key, value: m.value, category: m.category }));
+}
+function recordUsage(sessionId, provider, model, promptTokens, completionTokens) {
+  const s = loadStore();
+  s.usageStats.push({
+    id: s.usageStats.length + 1,
+    session_id: sessionId,
+    provider,
+    model,
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: promptTokens + completionTokens,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (s.usageStats.length > 1e4) {
+    s.usageStats = s.usageStats.slice(-1e4);
+  }
+  debouncedSave();
+}
+function getUsageStats() {
+  const s = loadStore();
+  let totalTokens = 0;
+  const byProvider = {};
+  for (const rec of s.usageStats) {
+    totalTokens += rec.total_tokens;
+    byProvider[rec.provider] = (byProvider[rec.provider] || 0) + rec.total_tokens;
+  }
+  return {
+    totalTokens,
+    totalRequests: s.usageStats.length,
+    byProvider
+  };
+}
+var COMPONENT3, DB_FILE, store, saveTimeout;
+var init_memory = __esm({
+  "src/memory/memory.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_logger();
+    init_encryption();
+    COMPONENT3 = "Memory";
+    DB_FILE = join2(TITAN_HOME, "titan-data.json");
+    store = null;
+    saveTimeout = null;
+  }
+});
+
+// src/agent/toolRunner.ts
+function registerTool(handler3) {
+  toolRegistry.set(handler3.name, handler3);
+  logger_default.debug(COMPONENT4, `Registered tool: ${handler3.name}`);
+}
+function getRegisteredTools() {
+  return Array.from(toolRegistry.values());
+}
+function getToolDefinitions() {
+  const config = loadConfig();
+  const allowed = new Set(config.security.allowedTools);
+  const denied = new Set(config.security.deniedTools);
+  return Array.from(toolRegistry.values()).filter((tool) => {
+    if (denied.has(tool.name)) return false;
+    if (allowed.size > 0 && !allowed.has(tool.name)) return false;
+    return true;
+  }).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}
+async function executeTool(toolCall) {
+  const config = loadConfig();
+  const startTime = Date.now();
+  const handler3 = toolRegistry.get(toolCall.function.name);
+  if (!handler3) {
+    return {
+      toolCallId: toolCall.id,
+      name: toolCall.function.name,
+      content: `Error: Unknown tool "${toolCall.function.name}"`,
+      success: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  if (config.security.deniedTools.includes(handler3.name)) {
+    return {
+      toolCallId: toolCall.id,
+      name: handler3.name,
+      content: `Error: Tool "${handler3.name}" is denied by security policy`,
+      success: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  try {
+    let args = {};
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = {};
+    }
+    logger_default.info(COMPONENT4, `Executing tool: ${handler3.name}`);
+    const timeout = config.security.commandTimeout || 3e4;
+    const result = await Promise.race([
+      handler3.execute(args),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Tool "${handler3.name}" timed out after ${timeout}ms`)), timeout)
+      )
+    ]);
+    const durationMs = Date.now() - startTime;
+    logger_default.info(COMPONENT4, `Tool ${handler3.name} completed in ${durationMs}ms`);
+    return {
+      toolCallId: toolCall.id,
+      name: handler3.name,
+      content: result,
+      success: true,
+      durationMs
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    const errorMsg = error.message;
+    logger_default.error(COMPONENT4, `Tool ${handler3.name} failed: ${errorMsg}`);
+    return {
+      toolCallId: toolCall.id,
+      name: handler3.name,
+      content: `Error: ${errorMsg}`,
+      success: false,
+      durationMs
+    };
+  }
+}
+async function executeTools(toolCalls) {
+  const config = loadConfig();
+  const maxConcurrent = config.security.maxConcurrentTasks || 5;
+  const results = [];
+  for (let i = 0; i < toolCalls.length; i += maxConcurrent) {
+    const batch = toolCalls.slice(i, i + maxConcurrent);
+    const batchResults = await Promise.all(batch.map(executeTool));
+    results.push(...batchResults);
+  }
+  return results;
+}
+var COMPONENT4, toolRegistry;
+var init_toolRunner = __esm({
+  "src/agent/toolRunner.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    COMPONENT4 = "ToolRunner";
+    toolRegistry = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/skills/builtin/shell.ts
+var shell_exports = {};
+__export(shell_exports, {
+  registerShellSkill: () => registerShellSkill
+});
+import { exec } from "child_process";
+function executeCommand(command, cwd, timeout = 3e4) {
+  return new Promise((resolve2, reject) => {
+    const proc = exec(command, {
+      cwd: cwd || process.cwd(),
+      timeout,
+      maxBuffer: 1024 * 1024 * 10,
+      // 10MB
+      shell: "/bin/bash"
+    }, (error, stdout, stderr) => {
+      if (error && error.killed) {
+        reject(new Error(`Command timed out after ${timeout}ms`));
+        return;
+      }
+      let output = "";
+      if (stdout) output += stdout;
+      if (stderr) output += (output ? "\n" : "") + `[stderr] ${stderr}`;
+      if (error) output += (output ? "\n" : "") + `[exit code: ${error.code}]`;
+      if (output.length > 5e4) {
+        output = output.slice(0, 25e3) + "\n\n... [output truncated] ...\n\n" + output.slice(-25e3);
+      }
+      resolve2(output || "(no output)");
+    });
+  });
+}
+function registerShellSkill() {
+  registerSkill(
+    {
+      name: "shell",
+      description: "Execute shell commands on the system",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    },
+    {
+      name: "shell",
+      description: "Execute a shell command on the user's system. Use this for running scripts, installing packages, checking system status, compiling code, git operations, and any other command-line task.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The shell command to execute"
+          },
+          cwd: {
+            type: "string",
+            description: "Working directory for the command (optional)"
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in milliseconds (default: 30000)"
+          }
+        },
+        required: ["command"]
+      },
+      execute: async (args) => {
+        const command = args.command;
+        const cwd = args.cwd;
+        const timeout = args.timeout || 3e4;
+        logger_default.info(COMPONENT5, `Executing: ${command}`);
+        return await executeCommand(command, cwd, timeout);
+      }
+    }
+  );
+}
+var COMPONENT5;
+var init_shell = __esm({
+  "src/skills/builtin/shell.ts"() {
+    "use strict";
+    init_registry();
+    init_logger();
+    COMPONENT5 = "Shell";
+  }
+});
+
+// src/skills/builtin/filesystem.ts
+var filesystem_exports = {};
+__export(filesystem_exports, {
+  registerFilesystemSkill: () => registerFilesystemSkill
+});
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, readdirSync, statSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, resolve } from "path";
+function registerFilesystemSkill() {
+  registerSkill(
+    { name: "read_file", description: "Read file contents", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "read_file",
+      description: "Read the contents of a file. Returns the text content of the file.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Absolute or relative path to the file" },
+          startLine: { type: "number", description: "Start line (1-indexed, optional)" },
+          endLine: { type: "number", description: "End line (1-indexed, optional)" }
+        },
+        required: ["path"]
+      },
+      execute: async (args) => {
+        const filePath = resolve(args.path);
+        if (!existsSync4(filePath)) return `Error: File not found: ${filePath}`;
+        try {
+          const content = readFileSync3(filePath, "utf-8");
+          const lines = content.split("\n");
+          const start = args.startLine || 1;
+          const end = args.endLine || lines.length;
+          const selected = lines.slice(start - 1, end);
+          return `File: ${filePath} (${lines.length} lines)
+---
+${selected.map((l, i) => `${start + i}: ${l}`).join("\n")}`;
+        } catch (e) {
+          return `Error reading file: ${e.message}`;
+        }
+      }
+    }
+  );
+  registerSkill(
+    { name: "write_file", description: "Write/create a file", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "write_file",
+      description: "Write content to a file. Creates the file and parent directories if they don't exist. Overwrites existing content.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file" },
+          content: { type: "string", description: "Content to write" }
+        },
+        required: ["path", "content"]
+      },
+      execute: async (args) => {
+        const filePath = resolve(args.path);
+        try {
+          const dir = join3(filePath, "..");
+          if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+          writeFileSync3(filePath, args.content, "utf-8");
+          return `Successfully wrote ${args.content.length} bytes to ${filePath}`;
+        } catch (e) {
+          return `Error writing file: ${e.message}`;
+        }
+      }
+    }
+  );
+  registerSkill(
+    { name: "edit_file", description: "Search and replace in a file", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "edit_file",
+      description: "Edit a file by replacing a target string with new content.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file" },
+          target: { type: "string", description: "Exact string to find and replace" },
+          replacement: { type: "string", description: "Replacement content" }
+        },
+        required: ["path", "target", "replacement"]
+      },
+      execute: async (args) => {
+        const filePath = resolve(args.path);
+        if (!existsSync4(filePath)) return `Error: File not found: ${filePath}`;
+        try {
+          let content = readFileSync3(filePath, "utf-8");
+          const target = args.target;
+          if (!content.includes(target)) return `Error: Target string not found in ${filePath}`;
+          content = content.replace(target, args.replacement);
+          writeFileSync3(filePath, content, "utf-8");
+          return `Successfully edited ${filePath}`;
+        } catch (e) {
+          return `Error editing file: ${e.message}`;
+        }
+      }
+    }
+  );
+  registerSkill(
+    { name: "list_dir", description: "List directory contents", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "list_dir",
+      description: "List the contents of a directory, showing files and subdirectories with sizes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the directory" },
+          recursive: { type: "boolean", description: "List recursively (default: false)" }
+        },
+        required: ["path"]
+      },
+      execute: async (args) => {
+        const dirPath = resolve(args.path);
+        if (!existsSync4(dirPath)) return `Error: Directory not found: ${dirPath}`;
+        try {
+          const entries = readdirSync(dirPath, { withFileTypes: true });
+          const lines = entries.map((entry) => {
+            const fullPath = join3(dirPath, entry.name);
+            if (entry.isDirectory()) {
+              return `\u{1F4C1} ${entry.name}/`;
+            }
+            const stat = statSync(fullPath);
+            const size = stat.size < 1024 ? `${stat.size}B` : stat.size < 1048576 ? `${(stat.size / 1024).toFixed(1)}KB` : `${(stat.size / 1048576).toFixed(1)}MB`;
+            return `\u{1F4C4} ${entry.name} (${size})`;
+          });
+          return `Directory: ${dirPath}
+${lines.join("\n")}`;
+        } catch (e) {
+          return `Error listing directory: ${e.message}`;
+        }
+      }
+    }
+  );
+}
+var init_filesystem = __esm({
+  "src/skills/builtin/filesystem.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
+
+// src/skills/builtin/web_search.ts
+var web_search_exports = {};
+__export(web_search_exports, {
+  registerWebSearchSkill: () => registerWebSearchSkill
+});
+function registerWebSearchSkill() {
+  registerSkill(
+    { name: "web_search", description: "Search the web", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "web_search",
+      description: "Search the web for information. Returns search results with titles, URLs, and snippets. Useful for finding current information, documentation, tutorials, etc.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "The search query" },
+          maxResults: { type: "number", description: "Maximum results to return (default: 5)" }
+        },
+        required: ["query"]
+      },
+      execute: async (args) => {
+        const query = args.query;
+        const maxResults = args.maxResults || 5;
+        logger_default.info(COMPONENT6, `Searching: ${query}`);
+        try {
+          const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+          const response = await fetch(url, {
+            headers: {
+              "User-Agent": "TITAN/1.0 (Autonomous AI Agent)"
+            }
+          });
+          if (!response.ok) {
+            return `Search failed with status ${response.status}`;
+          }
+          const html = await response.text();
+          const results = [];
+          const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>(.*?)<\/a>/gi;
+          let match;
+          while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+            const rawUrl = match[1];
+            const title = match[2].replace(/<[^>]*>/g, "").trim();
+            const snippet = match[3].replace(/<[^>]*>/g, "").trim();
+            const urlMatch = rawUrl.match(/uddg=([^&]*)/);
+            const decodedUrl = urlMatch ? decodeURIComponent(urlMatch[1]) : rawUrl;
+            if (title && decodedUrl) {
+              results.push({ title, url: decodedUrl, snippet });
+            }
+          }
+          if (results.length === 0) {
+            return `No results found for: "${query}"`;
+          }
+          return results.map((r, i) => `${i + 1}. **${r.title}**
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+        } catch (error) {
+          return `Search error: ${error.message}`;
+        }
+      }
+    }
+  );
+}
+var COMPONENT6;
+var init_web_search = __esm({
+  "src/skills/builtin/web_search.ts"() {
+    "use strict";
+    init_registry();
+    init_logger();
+    COMPONENT6 = "WebSearch";
+  }
+});
+
+// src/skills/builtin/cron.ts
+var cron_exports = {};
+__export(cron_exports, {
+  registerCronSkill: () => registerCronSkill
+});
+import { v4 as uuid } from "uuid";
+function registerCronSkill() {
+  registerSkill(
+    { name: "cron", description: "Manage scheduled tasks", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "cron",
+      description: "Create, list, enable/disable, or delete scheduled cron jobs. Jobs run automatically at specified intervals.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "delete", "enable", "disable"],
+            description: "Action to perform"
+          },
+          name: { type: "string", description: "Name for the cron job" },
+          schedule: { type: "string", description: 'Cron schedule expression (e.g., "0 9 * * *" for daily at 9am)' },
+          command: { type: "string", description: "Command to execute when the job runs" },
+          jobId: { type: "string", description: "Job ID (for delete/enable/disable)" }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = args.action;
+        const store2 = getDb();
+        switch (action) {
+          case "create": {
+            const name = args.name;
+            const schedule = args.schedule;
+            const command = args.command;
+            if (!name || !schedule || !command) return "Error: name, schedule, and command are required";
+            const id = uuid();
+            store2.cronJobs.push({
+              id,
+              name,
+              schedule,
+              command,
+              enabled: true,
+              created_at: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            logger_default.info(COMPONENT7, `Created cron job: ${name} (${schedule})`);
+            return `Created cron job "${name}" (ID: ${id})
+Schedule: ${schedule}
+Command: ${command}`;
+          }
+          case "list": {
+            if (store2.cronJobs.length === 0) return "No cron jobs configured.";
+            return store2.cronJobs.map(
+              (j) => `\u2022 ${j.name} [${j.enabled ? "\u2705 enabled" : "\u274C disabled"}]
+  ID: ${j.id}
+  Schedule: ${j.schedule}
+  Command: ${j.command}`
+            ).join("\n\n");
+          }
+          case "delete": {
+            const jobId = args.jobId;
+            if (!jobId) return "Error: jobId is required";
+            store2.cronJobs = store2.cronJobs.filter((j) => j.id !== jobId);
+            return `Deleted cron job: ${jobId}`;
+          }
+          case "enable": {
+            const eId = args.jobId;
+            if (!eId) return "Error: jobId is required";
+            const job = store2.cronJobs.find((j) => j.id === eId);
+            if (job) job.enabled = true;
+            return `Enabled cron job: ${eId}`;
+          }
+          case "disable": {
+            const dId = args.jobId;
+            if (!dId) return "Error: jobId is required";
+            const job = store2.cronJobs.find((j) => j.id === dId);
+            if (job) job.enabled = false;
+            return `Disabled cron job: ${dId}`;
+          }
+          default:
+            return `Unknown action: ${action}`;
+        }
+      }
+    }
+  );
+}
+var COMPONENT7;
+var init_cron = __esm({
+  "src/skills/builtin/cron.ts"() {
+    "use strict";
+    init_registry();
+    init_memory();
+    init_logger();
+    COMPONENT7 = "Cron";
+  }
+});
+
+// src/skills/builtin/webhook.ts
+var webhook_exports = {};
+__export(webhook_exports, {
+  getActiveWebhooks: () => getActiveWebhooks,
+  registerWebhookSkill: () => registerWebhookSkill
+});
+import { v4 as uuid2 } from "uuid";
+function getActiveWebhooks() {
+  return activeWebhooks;
+}
+function registerWebhookSkill() {
+  registerSkill(
+    { name: "webhook", description: "Manage webhook endpoints", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "webhook",
+      description: "Create, list, or delete HTTP webhook endpoints that trigger actions when called.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["create", "list", "delete"], description: "Action" },
+          name: { type: "string", description: "Webhook name" },
+          path: { type: "string", description: "URL path (e.g., /my-hook)" },
+          method: { type: "string", description: "HTTP method (GET/POST, default: POST)" },
+          handler: { type: "string", description: "Command to run when webhook is triggered" },
+          webhookId: { type: "string", description: "Webhook ID (for delete)" }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = args.action;
+        switch (action) {
+          case "create": {
+            const id = uuid2();
+            const name = args.name || `webhook-${id.slice(0, 8)}`;
+            const path2 = args.path || `/webhook/${id.slice(0, 8)}`;
+            const method = args.method || "POST";
+            const handler3 = args.handler || "";
+            activeWebhooks.set(id, { id, path: path2, name, method, handler: handler3 });
+            logger_default.info(COMPONENT8, `Created webhook: ${name} at ${path2}`);
+            return `Created webhook "${name}"
+  ID: ${id}
+  Path: ${path2}
+  Method: ${method}
+  Handler: ${handler3}`;
+          }
+          case "list": {
+            if (activeWebhooks.size === 0) return "No active webhooks.";
+            return Array.from(activeWebhooks.values()).map((w) => `\u2022 ${w.name}
+  ID: ${w.id}
+  ${w.method} ${w.path}
+  Handler: ${w.handler}`).join("\n\n");
+          }
+          case "delete": {
+            const wId = args.webhookId;
+            if (!wId) return "Error: webhookId is required";
+            activeWebhooks.delete(wId);
+            return `Deleted webhook: ${wId}`;
+          }
+          default:
+            return `Unknown action: ${action}`;
+        }
+      }
+    }
+  );
+}
+var COMPONENT8, activeWebhooks;
+var init_webhook = __esm({
+  "src/skills/builtin/webhook.ts"() {
+    "use strict";
+    init_registry();
+    init_logger();
+    COMPONENT8 = "Webhook";
+    activeWebhooks = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/skills/builtin/memory_skill.ts
+var memory_skill_exports = {};
+__export(memory_skill_exports, {
+  registerMemorySkill: () => registerMemorySkill
+});
+function registerMemorySkill() {
+  registerSkill(
+    { name: "memory", description: "Persistent memory management", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "memory",
+      description: "Store and recall persistent memories. Use this to remember user preferences, important facts, project details, and anything that should persist across conversations.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["remember", "recall", "search", "list"], description: "Action" },
+          category: { type: "string", description: 'Memory category (e.g., "preference", "fact", "project")' },
+          key: { type: "string", description: "Memory key/name" },
+          value: { type: "string", description: "Value to remember" },
+          query: { type: "string", description: "Search query (for search action)" }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = args.action;
+        const category = args.category || "general";
+        switch (action) {
+          case "remember": {
+            const key = args.key;
+            const value = args.value;
+            if (!key || !value) return "Error: key and value are required";
+            rememberFact(category, key, value);
+            return `Remembered: [${category}] ${key} = ${value}`;
+          }
+          case "recall": {
+            const rKey = args.key;
+            if (!rKey) return "Error: key is required";
+            const value = recallFact(category, rKey);
+            return value ? `[${category}] ${rKey} = ${value}` : `No memory found for [${category}] ${rKey}`;
+          }
+          case "search": {
+            const query = args.query;
+            const results = searchMemories(category !== "general" ? category : void 0, query);
+            if (results.length === 0) return "No matching memories found.";
+            return results.map((m) => `\u2022 [${m.category}] ${m.key}: ${m.value}`).join("\n");
+          }
+          case "list": {
+            const all = searchMemories(category !== "general" ? category : void 0);
+            if (all.length === 0) return "No memories stored yet.";
+            return all.map((m) => `\u2022 [${m.category}] ${m.key}: ${m.value}`).join("\n");
+          }
+          default:
+            return `Unknown action: ${action}`;
+        }
+      }
+    }
+  );
+}
+var init_memory_skill = __esm({
+  "src/skills/builtin/memory_skill.ts"() {
+    "use strict";
+    init_registry();
+    init_memory();
+  }
+});
+
+// src/skills/builtin/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  registerBrowserSkill: () => registerBrowserSkill
+});
+import { exec as exec2 } from "child_process";
+function registerBrowserSkill() {
+  registerSkill(
+    { name: "browser", description: "Browser control and web automation", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "browser",
+      description: "Control a Chromium-based browser to navigate websites, take snapshots, click elements, type text, evaluate JavaScript, and extract page content. Uses Chrome DevTools Protocol (CDP).",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["navigate", "snapshot", "click", "type", "evaluate", "extract", "screenshot"],
+            description: "Browser action to perform"
+          },
+          url: { type: "string", description: "URL to navigate to (for navigate action)" },
+          selector: { type: "string", description: "CSS selector for click/type actions" },
+          text: { type: "string", description: "Text to type (for type action)" },
+          script: { type: "string", description: "JavaScript code to evaluate (for evaluate action)" }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = args.action;
+        switch (action) {
+          case "navigate": {
+            const url = args.url;
+            if (!url) return "Error: url is required";
+            logger_default.info(COMPONENT9, `Navigating to: ${url}`);
+            return new Promise((resolve2) => {
+              exec2(`curl -sL --max-time 15 "${url}" | head -c 50000`, { timeout: 2e4 }, (err, stdout) => {
+                if (err) {
+                  resolve2(`Error fetching ${url}: ${err.message}`);
+                  return;
+                }
+                const text = stdout.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+                resolve2(`Page content from ${url}:
+${text.slice(0, 2e4)}`);
+              });
+            });
+          }
+          case "snapshot":
+          case "extract": {
+            const url = args.url;
+            if (!url) return "Error: url is required for snapshot/extract";
+            return new Promise((resolve2) => {
+              exec2(`curl -sL --max-time 15 "${url}" | head -c 50000`, { timeout: 2e4 }, (err, stdout) => {
+                if (err) {
+                  resolve2(`Error: ${err.message}`);
+                  return;
+                }
+                const title = stdout.match(/<title[^>]*>(.*?)<\/title>/i)?.[1] || "No title";
+                const desc = stdout.match(/<meta[^>]*name="description"[^>]*content="([^"]*)"[^>]*>/i)?.[1] || "";
+                const links = [];
+                const linkRegex = /<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi;
+                let m;
+                while ((m = linkRegex.exec(stdout)) !== null && links.length < 20) {
+                  const text = m[2].replace(/<[^>]*>/g, "").trim();
+                  if (text && m[1] && !m[1].startsWith("#")) links.push(`  ${text}: ${m[1]}`);
+                }
+                resolve2(`Page: ${title}
+Description: ${desc}
+Links:
+${links.join("\n")}`);
+              });
+            });
+          }
+          case "evaluate": {
+            const script = args.script;
+            if (!script) return "Error: script is required";
+            return `Note: Full CDP browser evaluation requires a running browser session. Script queued: ${script.slice(0, 200)}`;
+          }
+          case "screenshot": {
+            const url = args.url;
+            if (!url) return "Error: url is required";
+            return `Screenshot capture requires CDP connection to a running Chromium instance. Target: ${url}`;
+          }
+          case "click": {
+            const selector = args.selector;
+            if (!selector) return "Error: selector is required";
+            return `Click action requires CDP connection. Selector: ${selector}`;
+          }
+          case "type": {
+            const selector = args.selector;
+            const text = args.text;
+            if (!selector || !text) return "Error: selector and text are required";
+            return `Type action requires CDP connection. Selector: ${selector}, Text: ${text}`;
+          }
+          default:
+            return `Unknown browser action: ${action}`;
+        }
+      }
+    }
+  );
+}
+var COMPONENT9;
+var init_browser = __esm({
+  "src/skills/builtin/browser.ts"() {
+    "use strict";
+    init_registry();
+    init_logger();
+    COMPONENT9 = "Browser";
+  }
+});
+
+// src/agent/session.ts
+import { v4 as uuid3 } from "uuid";
+function getOrCreateSession(channel, userId, agentId = "default", isEncrypted = false) {
+  const sessionKey = `${channel}:${userId}:${agentId}`;
+  const cached = activeSessions.get(sessionKey);
+  if (cached && cached.status === "active") {
+    return cached;
+  }
+  const store2 = getDb();
+  const existing = store2.sessions.find(
+    (s) => s.channel === channel && s.user_id === userId && s.agent_id === agentId && s.status === "active"
+  );
+  if (existing) {
+    const lastActive = new Date(existing.last_active || existing.created_at).getTime();
+    if (Date.now() - lastActive > SESSION_TIMEOUT_MS) {
+      existing.status = "idle";
+      logger_default.debug(COMPONENT10, `Session ${existing.id} timed out, creating new one`);
+    } else {
+      const session2 = {
+        id: existing.id,
+        channel: existing.channel,
+        userId: existing.user_id,
+        agentId: existing.agent_id,
+        status: existing.status,
+        messageCount: existing.message_count,
+        createdAt: existing.created_at,
+        lastActive: existing.last_active,
+        // Note: If a session was encrypted but dropped from memory, we cannot recover the key
+        // A robust implementation would involve key exchange, but for now we warn:
+        e2eKey: void 0
+      };
+      if (isEncrypted) {
+        logger_default.warn(COMPONENT10, `Recovered session ${existing.id}, but E2E key was lost from memory.`);
+      }
+      activeSessions.set(sessionKey, session2);
+      return session2;
+    }
+  }
+  const session = {
+    id: uuid3(),
+    channel,
+    userId,
+    agentId,
+    status: "active",
+    messageCount: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (isEncrypted) {
+    Promise.resolve().then(() => (init_encryption(), encryption_exports)).then(({ generateKey: generateKey2 }) => {
+      session.e2eKey = generateKey2().toString("base64");
+      logger_default.info(COMPONENT10, `Generated E2E key for session ${session.id}`);
+    }).catch((err) => {
+      logger_default.error(COMPONENT10, `Failed to load encryption module: ${err}`);
+    });
+  }
+  store2.sessions.push({
+    id: session.id,
+    channel,
+    user_id: userId,
+    agent_id: agentId,
+    status: "active",
+    message_count: 0,
+    created_at: session.createdAt,
+    last_active: session.lastActive
+  });
+  activeSessions.set(sessionKey, session);
+  logger_default.info(COMPONENT10, `Created new session: ${session.id} (${channel}/${userId})`);
+  return session;
+}
+function addMessage(session, role, content, extra) {
+  const messageId = uuid3();
+  saveMessage({
+    id: messageId,
+    sessionId: session.id,
+    role,
+    content,
+    toolCalls: extra?.toolCalls,
+    toolCallId: extra?.toolCallId,
+    model: extra?.model,
+    tokenCount: extra?.tokenCount || 0
+  }, session.e2eKey);
+  session.messageCount++;
+  session.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  const store2 = getDb();
+  const sessionRec = store2.sessions.find((s) => s.id === session.id);
+  if (sessionRec) {
+    sessionRec.message_count = session.messageCount;
+    sessionRec.last_active = session.lastActive;
+  }
+}
+function getContextMessages(session, maxMessages = MAX_CONTEXT_MESSAGES) {
+  const history = getHistory(session.id, maxMessages, session.e2eKey);
+  return history.map((msg) => ({
+    role: msg.role,
+    content: msg.content,
+    toolCallId: msg.toolCallId || void 0,
+    toolCalls: msg.toolCalls ? JSON.parse(msg.toolCalls) : void 0
+  }));
+}
+function listSessions() {
+  const store2 = getDb();
+  return store2.sessions.filter((s) => s.status === "active").sort((a, b) => b.last_active.localeCompare(a.last_active)).map((s) => ({
+    id: s.id,
+    channel: s.channel,
+    userId: s.user_id,
+    agentId: s.agent_id,
+    status: s.status,
+    messageCount: s.message_count,
+    createdAt: s.created_at,
+    lastActive: s.last_active
+  }));
+}
+function closeSession(sessionId) {
+  const store2 = getDb();
+  const sessionRec = store2.sessions.find((s) => s.id === sessionId);
+  if (sessionRec) {
+    sessionRec.status = "closed";
+  }
+  for (const [key, session] of activeSessions) {
+    if (session.id === sessionId) {
+      activeSessions.delete(key);
+      break;
+    }
+  }
+  logger_default.info(COMPONENT10, `Closed session: ${sessionId}`);
+}
+var COMPONENT10, activeSessions;
+var init_session = __esm({
+  "src/agent/session.ts"() {
+    "use strict";
+    init_memory();
+    init_constants();
+    init_logger();
+    COMPONENT10 = "Session";
+    activeSessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/providers/base.ts
+var LLMProvider;
+var init_base = __esm({
+  "src/providers/base.ts"() {
+    "use strict";
+    LLMProvider = class {
+      /** Get the provider identifier from a model string like "anthropic/claude-3" */
+      static parseModelId(modelId) {
+        const parts = modelId.split("/");
+        if (parts.length >= 2) {
+          return { provider: parts[0], model: parts.slice(1).join("/") };
+        }
+        return { provider: "anthropic", model: modelId };
+      }
+    };
+  }
+});
+
+// src/providers/anthropic.ts
+import { v4 as uuid4 } from "uuid";
+var COMPONENT11, AnthropicProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT11 = "Anthropic";
+    AnthropicProvider = class extends LLMProvider {
+      name = "anthropic";
+      displayName = "Anthropic (Claude)";
+      get apiKey() {
+        const config = loadConfig();
+        return config.providers.anthropic.apiKey || process.env.ANTHROPIC_API_KEY || "";
+      }
+      get baseUrl() {
+        const config = loadConfig();
+        return config.providers.anthropic.baseUrl || "https://api.anthropic.com";
+      }
+      async chat(options) {
+        const model = options.model || "claude-sonnet-4-20250514";
+        const apiKey = this.apiKey;
+        if (!apiKey) throw new Error("Anthropic API key not configured");
+        logger_default.debug(COMPONENT11, `Chat request: model=${model}, messages=${options.messages.length}`);
+        const systemMessage = options.messages.find((m) => m.role === "system");
+        const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+        const body = {
+          model: model.replace("anthropic/", ""),
+          max_tokens: options.maxTokens || 8192,
+          messages: nonSystemMessages.map((m) => ({
+            role: m.role === "tool" ? "user" : m.role,
+            content: m.role === "tool" ? [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content }] : m.content
+          }))
+        };
+        if (systemMessage) {
+          body.system = systemMessage.content;
+        }
+        if (options.tools && options.tools.length > 0) {
+          body.tools = options.tools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description,
+            input_schema: t.function.parameters
+          }));
+        }
+        if (options.temperature !== void 0) {
+          body.temperature = options.temperature;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const content = data.content;
+        let textContent = "";
+        const toolCalls = [];
+        for (const block of content) {
+          if (block.type === "text") {
+            textContent += block.text;
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          }
+        }
+        const usage = data.usage;
+        return {
+          id: data.id || uuid4(),
+          content: textContent,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: usage ? {
+            promptTokens: usage.input_tokens,
+            completionTokens: usage.output_tokens,
+            totalTokens: usage.input_tokens + usage.output_tokens
+          } : void 0,
+          finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+          model
+        };
+      }
+      async *chatStream(options) {
+        try {
+          const response = await this.chat(options);
+          if (response.content) {
+            yield { type: "text", content: response.content };
+          }
+          if (response.toolCalls) {
+            for (const tc of response.toolCalls) {
+              yield { type: "tool_call", toolCall: tc };
+            }
+          }
+          yield { type: "done" };
+        } catch (error) {
+          yield { type: "error", error: error.message };
+        }
+      }
+      async listModels() {
+        return [
+          "claude-opus-4-0",
+          "claude-sonnet-4-20250514",
+          "claude-haiku-4-20250414",
+          "claude-3-5-sonnet-20241022",
+          "claude-3-5-haiku-20241022"
+        ];
+      }
+      async healthCheck() {
+        try {
+          if (!this.apiKey) return false;
+          const response = await fetch(`${this.baseUrl}/v1/messages`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": this.apiKey,
+              "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+              model: "claude-haiku-4-20250414",
+              max_tokens: 1,
+              messages: [{ role: "user", content: "ping" }]
+            })
+          });
+          return response.ok || response.status === 400;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/openai.ts
+import { v4 as uuid5 } from "uuid";
+var COMPONENT12, OpenAIProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT12 = "OpenAI";
+    OpenAIProvider = class extends LLMProvider {
+      name = "openai";
+      displayName = "OpenAI (GPT)";
+      get apiKey() {
+        const config = loadConfig();
+        return config.providers.openai.apiKey || process.env.OPENAI_API_KEY || "";
+      }
+      get baseUrl() {
+        const config = loadConfig();
+        return config.providers.openai.baseUrl || "https://api.openai.com";
+      }
+      async chat(options) {
+        const model = options.model || "gpt-4o";
+        const apiKey = this.apiKey;
+        if (!apiKey) throw new Error("OpenAI API key not configured");
+        logger_default.debug(COMPONENT12, `Chat request: model=${model}, messages=${options.messages.length}`);
+        const body = {
+          model: model.replace("openai/", ""),
+          messages: options.messages.map((m) => {
+            if (m.role === "tool") {
+              return { role: "tool", content: m.content, tool_call_id: m.toolCallId };
+            }
+            if (m.role === "assistant" && m.toolCalls) {
+              return {
+                role: "assistant",
+                content: m.content || null,
+                tool_calls: m.toolCalls.map((tc) => ({
+                  id: tc.id,
+                  type: "function",
+                  function: { name: tc.function.name, arguments: tc.function.arguments }
+                }))
+              };
+            }
+            return { role: m.role, content: m.content };
+          }),
+          max_tokens: options.maxTokens || 8192
+        };
+        if (options.tools && options.tools.length > 0) {
+          body.tools = options.tools;
+        }
+        if (options.temperature !== void 0) {
+          body.temperature = options.temperature;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`OpenAI API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const choices = data.choices;
+        const choice = choices[0];
+        const message = choice.message;
+        const toolCalls = [];
+        if (message.tool_calls) {
+          for (const tc of message.tool_calls) {
+            const fn = tc.function;
+            toolCalls.push({
+              id: tc.id,
+              type: "function",
+              function: { name: fn.name, arguments: fn.arguments }
+            });
+          }
+        }
+        const usage = data.usage;
+        return {
+          id: data.id || uuid5(),
+          content: message.content || "",
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: usage ? {
+            promptTokens: usage.prompt_tokens,
+            completionTokens: usage.completion_tokens,
+            totalTokens: usage.total_tokens
+          } : void 0,
+          finishReason: toolCalls.length > 0 ? "tool_calls" : choice.finish_reason || "stop",
+          model
+        };
+      }
+      async *chatStream(options) {
+        try {
+          const response = await this.chat(options);
+          if (response.content) {
+            yield { type: "text", content: response.content };
+          }
+          if (response.toolCalls) {
+            for (const tc of response.toolCalls) {
+              yield { type: "tool_call", toolCall: tc };
+            }
+          }
+          yield { type: "done" };
+        } catch (error) {
+          yield { type: "error", error: error.message };
+        }
+      }
+      async listModels() {
+        return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini", "o3-mini"];
+      }
+      async healthCheck() {
+        try {
+          if (!this.apiKey) return false;
+          const response = await fetch(`${this.baseUrl}/v1/models`, {
+            headers: { Authorization: `Bearer ${this.apiKey}` }
+          });
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/google.ts
+import { v4 as uuid6 } from "uuid";
+var COMPONENT13, GoogleProvider;
+var init_google = __esm({
+  "src/providers/google.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT13 = "Google";
+    GoogleProvider = class extends LLMProvider {
+      name = "google";
+      displayName = "Google (Gemini)";
+      get apiKey() {
+        const config = loadConfig();
+        return config.providers.google.apiKey || process.env.GOOGLE_API_KEY || "";
+      }
+      async chat(options) {
+        const model = (options.model || "gemini-2.0-flash").replace("google/", "");
+        const apiKey = this.apiKey;
+        if (!apiKey) throw new Error("Google API key not configured");
+        logger_default.debug(COMPONENT13, `Chat request: model=${model}, messages=${options.messages.length}`);
+        const systemInstruction = options.messages.find((m) => m.role === "system")?.content;
+        const contents = options.messages.filter((m) => m.role !== "system").map((m) => ({
+          role: m.role === "assistant" ? "model" : "user",
+          parts: [{ text: m.content }]
+        }));
+        const body = {
+          contents,
+          generationConfig: {
+            maxOutputTokens: options.maxTokens || 8192,
+            temperature: options.temperature ?? 0.7
+          }
+        };
+        if (systemInstruction) {
+          body.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        if (options.tools && options.tools.length > 0) {
+          body.tools = [{
+            functionDeclarations: options.tools.map((t) => ({
+              name: t.function.name,
+              description: t.function.description,
+              parameters: t.function.parameters
+            }))
+          }];
+        }
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Google API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const candidates = data.candidates;
+        let textContent = "";
+        const toolCalls = [];
+        if (candidates && candidates.length > 0) {
+          const parts = candidates[0].content?.parts || [];
+          for (const part of parts) {
+            if (part.text) {
+              textContent += part.text;
+            }
+            if (part.functionCall) {
+              const fc = part.functionCall;
+              toolCalls.push({
+                id: uuid6(),
+                type: "function",
+                function: {
+                  name: fc.name,
+                  arguments: JSON.stringify(fc.args)
+                }
+              });
+            }
+          }
+        }
+        const usageMeta = data.usageMetadata;
+        return {
+          id: uuid6(),
+          content: textContent,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: usageMeta ? {
+            promptTokens: usageMeta.promptTokenCount || 0,
+            completionTokens: usageMeta.candidatesTokenCount || 0,
+            totalTokens: usageMeta.totalTokenCount || 0
+          } : void 0,
+          finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+          model: `google/${model}`
+        };
+      }
+      async *chatStream(options) {
+        try {
+          const response = await this.chat(options);
+          if (response.content) yield { type: "text", content: response.content };
+          if (response.toolCalls) {
+            for (const tc of response.toolCalls) yield { type: "tool_call", toolCall: tc };
+          }
+          yield { type: "done" };
+        } catch (error) {
+          yield { type: "error", error: error.message };
+        }
+      }
+      async listModels() {
+        return ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash", "gemini-1.5-pro"];
+      }
+      async healthCheck() {
+        try {
+          if (!this.apiKey) return false;
+          const url = `https://generativelanguage.googleapis.com/v1beta/models?key=${this.apiKey}`;
+          const response = await fetch(url);
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/ollama.ts
+import { v4 as uuid7 } from "uuid";
+var COMPONENT14, OllamaProvider;
+var init_ollama = __esm({
+  "src/providers/ollama.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT14 = "Ollama";
+    OllamaProvider = class extends LLMProvider {
+      name = "ollama";
+      displayName = "Ollama (Local)";
+      get baseUrl() {
+        const config = loadConfig();
+        return config.providers.ollama.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+      }
+      async chat(options) {
+        const model = (options.model || "llama3.1").replace("ollama/", "");
+        logger_default.debug(COMPONENT14, `Chat request: model=${model}, messages=${options.messages.length}`);
+        const body = {
+          model,
+          messages: options.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          stream: false,
+          options: {
+            num_predict: options.maxTokens || 8192,
+            temperature: options.temperature ?? 0.7
+          }
+        };
+        if (options.tools && options.tools.length > 0) {
+          body.tools = options.tools.map((t) => ({
+            type: "function",
+            function: {
+              name: t.function.name,
+              description: t.function.description,
+              parameters: t.function.parameters
+            }
+          }));
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Ollama error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const message = data.message;
+        const toolCalls = [];
+        if (message.tool_calls) {
+          for (const tc of message.tool_calls) {
+            const fn = tc.function;
+            toolCalls.push({
+              id: uuid7(),
+              type: "function",
+              function: {
+                name: fn.name,
+                arguments: JSON.stringify(fn.arguments)
+              }
+            });
+          }
+        }
+        return {
+          id: uuid7(),
+          content: message.content || "",
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: {
+            promptTokens: data.prompt_eval_count || 0,
+            completionTokens: data.eval_count || 0,
+            totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+          },
+          finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+          model: `ollama/${model}`
+        };
+      }
+      async *chatStream(options) {
+        try {
+          const response = await this.chat(options);
+          if (response.content) yield { type: "text", content: response.content };
+          if (response.toolCalls) {
+            for (const tc of response.toolCalls) yield { type: "tool_call", toolCall: tc };
+          }
+          yield { type: "done" };
+        } catch (error) {
+          yield { type: "error", error: error.message };
+        }
+      }
+      async listModels() {
+        try {
+          const response = await fetch(`${this.baseUrl}/api/tags`);
+          if (!response.ok) return [];
+          const data = await response.json();
+          return (data.models || []).map((m) => m.name);
+        } catch {
+          return [];
+        }
+      }
+      async healthCheck() {
+        try {
+          const response = await fetch(`${this.baseUrl}/api/tags`);
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/router.ts
+function initProviders() {
+  if (initialized) return;
+  providers.set("anthropic", new AnthropicProvider());
+  providers.set("openai", new OpenAIProvider());
+  providers.set("google", new GoogleProvider());
+  providers.set("ollama", new OllamaProvider());
+  initialized = true;
+}
+function resolveModel(modelId) {
+  initProviders();
+  const { provider: providerName, model } = LLMProvider.parseModelId(modelId);
+  const provider = providers.get(providerName);
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerName}. Available: ${Array.from(providers.keys()).join(", ")}`);
+  }
+  return { provider, model };
+}
+async function chat(options) {
+  const modelId = options.model || "anthropic/claude-sonnet-4-20250514";
+  const { provider, model } = resolveModel(modelId);
+  logger_default.info(COMPONENT15, `Routing to ${provider.displayName} (model: ${model})`);
+  try {
+    return await provider.chat({ ...options, model });
+  } catch (error) {
+    logger_default.error(COMPONENT15, `Provider ${provider.name} failed: ${error.message}`);
+    const failoverOrder = ["anthropic", "openai", "google", "ollama"];
+    for (const fallbackName of failoverOrder) {
+      if (fallbackName === provider.name) continue;
+      const fallback = providers.get(fallbackName);
+      if (!fallback) continue;
+      try {
+        const healthy = await fallback.healthCheck();
+        if (!healthy) continue;
+        const models = await fallback.listModels();
+        if (models.length === 0) continue;
+        logger_default.warn(COMPONENT15, `Failing over to ${fallback.displayName} (model: ${models[0]})`);
+        return await fallback.chat({ ...options, model: models[0] });
+      } catch {
+        continue;
+      }
+    }
+    throw error;
+  }
+}
+async function healthCheckAll() {
+  initProviders();
+  const results = {};
+  for (const [name, provider] of providers) {
+    try {
+      results[name] = await provider.healthCheck();
+    } catch {
+      results[name] = false;
+    }
+  }
+  return results;
+}
+var COMPONENT15, providers, initialized;
+var init_router = __esm({
+  "src/providers/router.ts"() {
+    "use strict";
+    init_base();
+    init_anthropic();
+    init_openai();
+    init_google();
+    init_ollama();
+    init_logger();
+    COMPONENT15 = "Router";
+    providers = /* @__PURE__ */ new Map();
+    initialized = false;
+  }
+});
+
+// src/memory/learning.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+function loadKnowledgeBase() {
+  if (kb) return kb;
+  ensureDir(TITAN_HOME);
+  if (existsSync5(KNOWLEDGE_FILE)) {
+    try {
+      kb = JSON.parse(readFileSync4(KNOWLEDGE_FILE, "utf-8"));
+      kb.entries = kb.entries || [];
+      kb.toolSuccessRates = kb.toolSuccessRates || {};
+      kb.errorPatterns = kb.errorPatterns || {};
+      kb.userCorrections = kb.userCorrections || [];
+      kb.conversationInsights = kb.conversationInsights || [];
+    } catch {
+      kb = createEmptyKB();
+    }
+  } else {
+    kb = createEmptyKB();
+  }
+  return kb;
+}
+function createEmptyKB() {
+  return {
+    entries: [],
+    toolSuccessRates: {},
+    errorPatterns: {},
+    userCorrections: [],
+    conversationInsights: []
+  };
+}
+function debouncedSave2() {
+  if (saveTimeout2) clearTimeout(saveTimeout2);
+  saveTimeout2 = setTimeout(() => {
+    if (!kb) return;
+    ensureDir(TITAN_HOME);
+    writeFileSync4(KNOWLEDGE_FILE, JSON.stringify(kb, null, 2), "utf-8");
+  }, 2e3);
+}
+function recordToolResult(toolName, success, context, error) {
+  const k = loadKnowledgeBase();
+  if (!k.toolSuccessRates[toolName]) {
+    k.toolSuccessRates[toolName] = { success: 0, fail: 0, total: 0 };
+  }
+  k.toolSuccessRates[toolName].total++;
+  if (success) {
+    k.toolSuccessRates[toolName].success++;
+  } else {
+    k.toolSuccessRates[toolName].fail++;
+    if (error) {
+      const pattern = error.slice(0, 200);
+      if (!k.errorPatterns[pattern]) {
+        k.errorPatterns[pattern] = { count: 0, lastSeen: "" };
+      }
+      k.errorPatterns[pattern].count++;
+      k.errorPatterns[pattern].lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  debouncedSave2();
+}
+function getToolRecommendations() {
+  const k = loadKnowledgeBase();
+  const recommendations = {};
+  for (const [tool, stats] of Object.entries(k.toolSuccessRates)) {
+    if (stats.total > 0) {
+      recommendations[tool] = stats.success / stats.total;
+    }
+  }
+  return recommendations;
+}
+function getLearningContext() {
+  const k = loadKnowledgeBase();
+  const parts = [];
+  const topEntries = k.entries.filter((e) => e.score > 0.6).sort((a, b) => b.score - a.score).slice(0, 10);
+  if (topEntries.length > 0) {
+    parts.push("Key learned facts:");
+    for (const e of topEntries) {
+      parts.push(`- [${e.category}] ${e.content}`);
+    }
+  }
+  const toolRecs = getToolRecommendations();
+  const bestTools = Object.entries(toolRecs).filter(([_, rate]) => rate > 0.8).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (bestTools.length > 0) {
+    parts.push("\nMost reliable tools:");
+    for (const [tool, rate] of bestTools) {
+      parts.push(`- ${tool}: ${Math.round(rate * 100)}% success rate`);
+    }
+  }
+  const frequentErrors = Object.entries(k.errorPatterns).filter(([_, info]) => info.count > 2).sort((a, b) => b[1].count - a[1].count).slice(0, 3);
+  if (frequentErrors.length > 0) {
+    parts.push("\nCommon errors to avoid:");
+    for (const [pattern, info] of frequentErrors) {
+      parts.push(`- ${pattern.slice(0, 100)} (seen ${info.count}x)${info.resolution ? ` \u2192 Fix: ${info.resolution}` : ""}`);
+    }
+  }
+  return parts.join("\n");
+}
+var KNOWLEDGE_FILE, kb, saveTimeout2;
+var init_learning = __esm({
+  "src/memory/learning.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_logger();
+    KNOWLEDGE_FILE = join4(TITAN_HOME, "knowledge.json");
+    kb = null;
+    saveTimeout2 = null;
+  }
+});
+
+// src/agent/agent.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+function readPromptFile(path2) {
+  try {
+    if (existsSync6(path2)) return readFileSync5(path2, "utf-8");
+  } catch {
+  }
+  return "";
+}
+function buildSystemPrompt(config) {
+  const customPrompt = config.agent.systemPrompt || "";
+  const memories = searchMemories("preference");
+  const memoryContext = memories.length > 0 ? `
+
+User preferences I remember:
+${memories.map((m) => `- ${m.key}: ${m.value}`).join("\n")}` : "";
+  const agentsMd = readPromptFile(AGENTS_MD);
+  const soulMd = readPromptFile(SOUL_MD);
+  const toolsMd = readPromptFile(TOOLS_MD);
+  const workspaceContext = [
+    agentsMd ? `
+## Agent Instructions (AGENTS.md)
+${agentsMd}` : "",
+    soulMd ? `
+## Personality (SOUL.md)
+${soulMd}` : "",
+    toolsMd ? `
+## Tool Notes (TOOLS.md)
+${toolsMd}` : ""
+  ].filter(Boolean).join("\n");
+  const learningContext = getLearningContext();
+  return `You are ${TITAN_NAME}, The Intelligent Task Automation Network \u2014 a powerful personal AI assistant.
+
+## Core Capabilities
+- Execute shell commands and scripts on the user's system
+- Read, write, edit, and manage files
+- Browse the web and extract information (browser control via CDP)
+- Schedule automated tasks with cron
+- Set up webhook endpoints
+- Search the web for current information
+- Control browser sessions (navigate, snapshot, evaluate)
+- Manage agent sessions (list, history, send, close)
+- Remember facts and user preferences persistently
+
+## Behavior Guidelines
+- Be proactive: if a task implies follow-up actions, suggest or perform them
+- Be concise but thorough in responses
+- When executing commands, always explain what you're doing and why
+- If a task could be destructive (deleting files, etc.), confirm with the user first
+- Use tools when they would be helpful \u2014 don't just describe what could be done
+- Remember important information about the user for future conversations
+- If you encounter an error, try alternative approaches before reporting failure
+
+## Security
+- Never expose API keys, passwords, or other secrets
+- Don't execute commands that could compromise system security without explicit approval
+- Respect file system boundaries set in the configuration
+
+## Continuous Learning
+You get smarter with every interaction. Below is your accumulated knowledge:
+${learningContext}
+${customPrompt ? `
+## Custom Instructions
+${customPrompt}` : ""}${workspaceContext}${memoryContext}`;
+}
+async function processMessage(message, channel = "cli", userId = "default") {
+  const startTime = Date.now();
+  const config = loadConfig();
+  const session = getOrCreateSession(channel, userId);
+  logger_default.info(COMPONENT16, `Processing message in session ${session.id} (${channel}/${userId})`);
+  addMessage(session, "user", message);
+  const systemPrompt = buildSystemPrompt(config);
+  const historyMessages = getContextMessages(session);
+  const tools = getToolDefinitions();
+  const messages = [
+    { role: "system", content: systemPrompt },
+    ...historyMessages
+  ];
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  const toolsUsed = [];
+  let finalContent = "";
+  let modelUsed = config.agent.model;
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    logger_default.debug(COMPONENT16, `Round ${round + 1}: ${messages.length} messages, ${tools.length} tools`);
+    const response = await chat({
+      model: config.agent.model,
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      maxTokens: config.agent.maxTokens,
+      temperature: config.agent.temperature
+    });
+    modelUsed = response.model;
+    totalPromptTokens += response.usage?.promptTokens || 0;
+    totalCompletionTokens += response.usage?.completionTokens || 0;
+    if (!response.toolCalls || response.toolCalls.length === 0) {
+      finalContent = response.content;
+      break;
+    }
+    logger_default.info(COMPONENT16, `LLM requested ${response.toolCalls.length} tool call(s)`);
+    messages.push({
+      role: "assistant",
+      content: response.content || "",
+      toolCalls: response.toolCalls
+    });
+    const toolResults = await executeTools(response.toolCalls);
+    for (const result of toolResults) {
+      toolsUsed.push(result.name);
+      messages.push({
+        role: "tool",
+        content: result.content,
+        toolCallId: result.toolCallId
+      });
+      const success = !result.content.toLowerCase().includes("error:");
+      recordToolResult(result.name, success, void 0, success ? void 0 : result.content.slice(0, 200));
+    }
+    if (round === MAX_TOOL_ROUNDS - 1) {
+      finalContent = response.content || "I completed the tool operations. Let me know if you need anything else.";
+    }
+  }
+  addMessage(session, "assistant", finalContent, {
+    model: modelUsed,
+    tokenCount: totalCompletionTokens
+  });
+  const { provider: providerName } = { provider: modelUsed.split("/")[0] || "unknown" };
+  recordUsage(session.id, providerName, modelUsed, totalPromptTokens, totalCompletionTokens);
+  const durationMs = Date.now() - startTime;
+  logger_default.info(COMPONENT16, `Response generated in ${durationMs}ms (${totalPromptTokens + totalCompletionTokens} tokens)`);
+  return {
+    content: finalContent,
+    sessionId: session.id,
+    toolsUsed: [...new Set(toolsUsed)],
+    tokenUsage: {
+      prompt: totalPromptTokens,
+      completion: totalCompletionTokens,
+      total: totalPromptTokens + totalCompletionTokens
+    },
+    model: modelUsed,
+    durationMs
+  };
+}
+var COMPONENT16, MAX_TOOL_ROUNDS;
+var init_agent = __esm({
+  "src/agent/agent.ts"() {
+    "use strict";
+    init_router();
+    init_config();
+    init_session();
+    init_toolRunner();
+    init_memory();
+    init_learning();
+    init_logger();
+    init_constants();
+    COMPONENT16 = "Agent";
+    MAX_TOOL_ROUNDS = 10;
+  }
+});
+
+// src/skills/builtin/sessions.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  registerSessionsSkill: () => registerSessionsSkill
+});
+function registerSessionsSkill() {
+  registerSkill(
+    { name: "sessions_list", description: "List active sessions", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_list",
+      description: "List all active agent sessions with their IDs, channels, users, and message counts.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      execute: async () => {
+        const sessions = listSessions();
+        if (sessions.length === 0) return "No active sessions.";
+        return sessions.map(
+          (s) => `\u2022 ${s.id.slice(0, 8)} | ${s.channel} | user: ${s.userId} | msgs: ${s.messageCount} | last active: ${s.lastActive}`
+        ).join("\n");
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_history", description: "Get session message history", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_history",
+      description: "Retrieve the recent message history for a specific session.",
+      parameters: {
+        type: "object",
+        properties: {
+          sessionChannel: { type: "string", description: "Channel of the session" },
+          sessionUserId: { type: "string", description: "User ID of the session" },
+          limit: { type: "number", description: "Max messages to return (default: 20)" }
+        },
+        required: ["sessionChannel", "sessionUserId"]
+      },
+      execute: async (args) => {
+        const channel = args.sessionChannel;
+        const userId = args.sessionUserId;
+        const limit = args.limit || 20;
+        const session = getOrCreateSession(channel, userId);
+        const messages = getContextMessages(session, limit);
+        if (messages.length === 0) return `No messages in session ${channel}/${userId}.`;
+        return messages.map(
+          (m) => `[${m.role}] ${m.content.slice(0, 500)}`
+        ).join("\n---\n");
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_send", description: "Send a message to another session", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_send",
+      description: "Send a message to a specific user's session on a channel, triggering agent processing.",
+      parameters: {
+        type: "object",
+        properties: {
+          targetChannel: { type: "string", description: 'Target channel (e.g., "discord", "telegram")' },
+          targetUserId: { type: "string", description: "Target user ID" },
+          message: { type: "string", description: "Message to send" }
+        },
+        required: ["targetChannel", "targetUserId", "message"]
+      },
+      execute: async (args) => {
+        const channel = args.targetChannel;
+        const userId = args.targetUserId;
+        const message = args.message;
+        logger_default.info(COMPONENT17, `Sending inter-session message to ${channel}/${userId}`);
+        try {
+          const response = await processMessage(message, channel, userId);
+          return `Message delivered to ${channel}/${userId}. Response: ${response.content.slice(0, 500)}`;
+        } catch (error) {
+          return `Error sending to ${channel}/${userId}: ${error.message}`;
+        }
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_close", description: "Close a session", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_close",
+      description: "Close a specific session by its session ID.",
+      parameters: {
+        type: "object",
+        properties: {
+          sessionId: { type: "string", description: "Session ID to close" }
+        },
+        required: ["sessionId"]
+      },
+      execute: async (args) => {
+        const sessionId = args.sessionId;
+        closeSession(sessionId);
+        return `Session ${sessionId} closed.`;
+      }
+    }
+  );
+}
+var COMPONENT17;
+var init_sessions = __esm({
+  "src/skills/builtin/sessions.ts"() {
+    "use strict";
+    init_registry();
+    init_session();
+    init_agent();
+    init_logger();
+    COMPONENT17 = "Sessions";
+  }
+});
+
+// src/skills/builtin/process.ts
+var process_exports = {};
+__export(process_exports, {
+  registerProcessSkill: () => registerProcessSkill
+});
+import { exec as exec3, spawn } from "child_process";
+import { v4 as uuid8 } from "uuid";
+function registerProcessSkill() {
+  registerSkill(
+    { name: "exec", description: "Execute commands with background/timeout support", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "exec",
+      description: "Execute a shell command. Supports background execution (returns immediately with sessionId), timeouts, and PTY mode. Use the process tool to poll/kill background processes.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute" },
+          background: { type: "boolean", description: "Run in background (default: false)" },
+          timeout: { type: "number", description: "Timeout in seconds (default: 30, max: 1800)" },
+          cwd: { type: "string", description: "Working directory" }
+        },
+        required: ["command"]
+      },
+      execute: async (args) => {
+        const command = args.command;
+        const background = args.background || false;
+        const timeout = Math.min(args.timeout || 30, 1800) * 1e3;
+        const cwd = args.cwd || process.cwd();
+        if (background) {
+          const id = uuid8().slice(0, 8);
+          const child = spawn("bash", ["-c", command], { cwd, stdio: "pipe" });
+          const managed = {
+            id,
+            command,
+            pid: child.pid || 0,
+            status: "running",
+            exitCode: null,
+            output: [],
+            startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            process: child
+          };
+          child.stdout?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            managed.output.push(...lines);
+            if (managed.output.length > MAX_OUTPUT_LINES) {
+              managed.output = managed.output.slice(-MAX_OUTPUT_LINES);
+            }
+          });
+          child.stderr?.on("data", (data) => {
+            managed.output.push(...data.toString().split("\n"));
+          });
+          child.on("exit", (code) => {
+            managed.status = "exited";
+            managed.exitCode = code;
+            managed.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+          });
+          processes.set(id, managed);
+          logger_default.info(COMPONENT18, `Background process started: ${id} (PID: ${managed.pid})`);
+          return `Process started in background.
+Session ID: ${id}
+PID: ${managed.pid}
+Use the "process" tool to poll, log, or kill this process.`;
+        }
+        return new Promise((resolve2) => {
+          exec3(command, { cwd, timeout, maxBuffer: 1024 * 1024 * 5 }, (err, stdout, stderr) => {
+            if (err && err.killed) {
+              resolve2(`Command timed out after ${timeout / 1e3}s.
+
+Partial output:
+${stdout.slice(0, 5e3)}`);
+              return;
+            }
+            const output = (stdout + (stderr ? `
+STDERR:
+${stderr}` : "")).trim();
+            if (err) {
+              resolve2(`Exit code: ${err.code}
+${output.slice(0, 1e4)}`);
+            } else {
+              resolve2(output.slice(0, 1e4) || "(no output)");
+            }
+          });
+        });
+      }
+    }
+  );
+  registerSkill(
+    { name: "process", description: "Manage background processes", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "process",
+      description: "Manage background processes: list running processes, poll for output, view logs, write to stdin, kill, or clear completed processes.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "poll", "log", "write", "kill", "clear", "remove"],
+            description: "Action to perform"
+          },
+          sessionId: { type: "string", description: "Process session ID (for poll/log/write/kill/remove)" },
+          input: { type: "string", description: "Input to write to process stdin (for write action)" },
+          limit: { type: "number", description: "Number of log lines to return (for log action, default: 50)" }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = args.action;
+        switch (action) {
+          case "list": {
+            const procs = Array.from(processes.values());
+            if (procs.length === 0) return "No managed processes.";
+            return procs.map(
+              (p) => `\u2022 ${p.id} | PID: ${p.pid} | ${p.status} | cmd: ${p.command.slice(0, 80)} | started: ${p.startedAt}${p.exitCode !== null ? ` | exit: ${p.exitCode}` : ""}`
+            ).join("\n");
+          }
+          case "poll": {
+            const proc = processes.get(args.sessionId);
+            if (!proc) return `Process ${args.sessionId} not found.`;
+            const lastLines = proc.output.slice(-20).join("\n");
+            return `Status: ${proc.status}${proc.exitCode !== null ? ` (exit: ${proc.exitCode})` : ""}
+Output (last 20 lines):
+${lastLines || "(no output yet)"}`;
+          }
+          case "log": {
+            const proc = processes.get(args.sessionId);
+            if (!proc) return `Process ${args.sessionId} not found.`;
+            const limit = args.limit || 50;
+            return proc.output.slice(-limit).join("\n") || "(no output)";
+          }
+          case "write": {
+            const proc = processes.get(args.sessionId);
+            if (!proc || proc.status !== "running") return `Process ${args.sessionId} not running.`;
+            const input = args.input;
+            if (!input) return "No input provided.";
+            proc.process.stdin?.write(input + "\n");
+            return `Wrote to stdin: ${input}`;
+          }
+          case "kill": {
+            const proc = processes.get(args.sessionId);
+            if (!proc) return `Process ${args.sessionId} not found.`;
+            proc.process.kill("SIGTERM");
+            setTimeout(() => proc.process.kill("SIGKILL"), 5e3);
+            return `Sent SIGTERM to process ${proc.id} (PID: ${proc.pid})`;
+          }
+          case "clear": {
+            const cleared = Array.from(processes.values()).filter((p) => p.status === "exited");
+            for (const p of cleared) processes.delete(p.id);
+            return `Cleared ${cleared.length} completed processes.`;
+          }
+          case "remove": {
+            if (processes.delete(args.sessionId)) {
+              return `Removed process ${args.sessionId}.`;
+            }
+            return `Process ${args.sessionId} not found.`;
+          }
+          default:
+            return `Unknown action: ${action}`;
+        }
+      }
+    }
+  );
+}
+var COMPONENT18, processes, MAX_OUTPUT_LINES;
+var init_process = __esm({
+  "src/skills/builtin/process.ts"() {
+    "use strict";
+    init_registry();
+    init_logger();
+    COMPONENT18 = "Process";
+    processes = /* @__PURE__ */ new Map();
+    MAX_OUTPUT_LINES = 500;
+  }
+});
+
+// src/skills/builtin/web_fetch.ts
+var web_fetch_exports = {};
+__export(web_fetch_exports, {
+  registerWebFetchSkill: () => registerWebFetchSkill
+});
+import { exec as exec4 } from "child_process";
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n\n").replace(/<\/div>/gi, "\n").replace(/<\/h[1-6]>/gi, "\n\n").replace(/<li>/gi, "\u2022 ").replace(/<\/li>/gi, "\n").replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+function htmlToMarkdown(html) {
+  let md = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
+  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, "# $1\n");
+  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, "## $1\n");
+  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, "### $1\n");
+  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, "#### $1\n");
+  md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<(strong|b)>(.*?)<\/\1>/gi, "**$2**");
+  md = md.replace(/<(em|i)>(.*?)<\/\1>/gi, "*$2*");
+  md = md.replace(/<code>(.*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<pre>([\s\S]*?)<\/pre>/gi, "```\n$1\n```\n");
+  md = md.replace(/<li>/gi, "- ");
+  md = md.replace(/<\/li>/gi, "\n");
+  md = md.replace(/<img[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*>/gi, "![$1]($2)");
+  md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*>/gi, "![$2]($1)");
+  md = md.replace(/<br\s*\/?>/gi, "\n");
+  md = md.replace(/<\/p>/gi, "\n\n");
+  md = md.replace(/<[^>]*>/g, "");
+  md = md.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+  md = md.replace(/\n{3,}/g, "\n\n");
+  return md.trim();
+}
+function registerWebFetchSkill() {
+  registerSkill(
+    { name: "web_fetch", description: "Fetch URL content", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "web_fetch",
+      description: "Fetch a URL and extract its content as markdown or plain text. Good for reading documentation, articles, and web pages. For JS-heavy sites, prefer the browser tool.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "URL to fetch" },
+          extractMode: { type: "string", enum: ["markdown", "text"], description: "Output format (default: markdown)" },
+          maxChars: { type: "number", description: "Max characters to return (default: 50000)" }
+        },
+        required: ["url"]
+      },
+      execute: async (args) => {
+        const url = args.url;
+        const mode = args.extractMode || "markdown";
+        const maxChars = Math.min(args.maxChars || 5e4, 1e5);
+        return new Promise((resolve2) => {
+          exec4(
+            `curl -sL --max-time 20 -A "Mozilla/5.0 (compatible; TITAN/1.0)" "${url}" | head -c 200000`,
+            { timeout: 25e3, maxBuffer: 1024 * 1024 * 5 },
+            (err, stdout) => {
+              if (err) {
+                resolve2(`Error fetching ${url}: ${err.message}`);
+                return;
+              }
+              if (!stdout.trim()) {
+                resolve2(`Empty response from ${url}`);
+                return;
+              }
+              const title = stdout.match(/<title[^>]*>(.*?)<\/title>/i)?.[1] || "Untitled";
+              const content = mode === "markdown" ? htmlToMarkdown(stdout) : htmlToText(stdout);
+              resolve2(`# ${title}
+
+Source: ${url}
+
+${content.slice(0, maxChars)}`);
+            }
+          );
+        });
+      }
+    }
+  );
+}
+var init_web_fetch = __esm({
+  "src/skills/builtin/web_fetch.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
+
+// src/skills/builtin/apply_patch.ts
+var apply_patch_exports = {};
+__export(apply_patch_exports, {
+  registerApplyPatchSkill: () => registerApplyPatchSkill
+});
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
+import { dirname as dirname2 } from "path";
+function registerApplyPatchSkill() {
+  registerSkill(
+    { name: "apply_patch", description: "Apply unified diff patches to files", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "apply_patch",
+      description: "Apply a unified diff patch to one or more files. The patch should be in unified diff format (like git diff output). Creates new files if they don't exist.",
+      parameters: {
+        type: "object",
+        properties: {
+          patch: { type: "string", description: "Unified diff patch content" },
+          cwd: { type: "string", description: "Working directory for relative paths" }
+        },
+        required: ["patch"]
+      },
+      execute: async (args) => {
+        const patch = args.patch;
+        const cwd = args.cwd || process.cwd();
+        const results = [];
+        const filePatches = patch.split(/^diff --git/m).filter(Boolean);
+        if (filePatches.length === 0) {
+          return applySimplePatch(patch, cwd);
+        }
+        for (const filePatch of filePatches) {
+          try {
+            const oldFile = filePatch.match(/^--- a\/(.+)$/m)?.[1];
+            const newFile = filePatch.match(/^\+\+\+ b\/(.+)$/m)?.[1];
+            const targetFile = newFile || oldFile;
+            if (!targetFile) {
+              results.push(`\u26A0\uFE0F Could not determine target file`);
+              continue;
+            }
+            const fullPath = targetFile.startsWith("/") ? targetFile : `${cwd}/${targetFile}`;
+            const isNewFile = oldFile === "/dev/null" || !existsSync7(fullPath);
+            if (isNewFile) {
+              const addedLines = filePatch.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1)).join("\n");
+              ensureDir(dirname2(fullPath));
+              writeFileSync5(fullPath, addedLines, "utf-8");
+              results.push(`\u2705 Created: ${targetFile}`);
+            } else {
+              let content = readFileSync6(fullPath, "utf-8");
+              const hunks = filePatch.match(/@@ .+ @@[\s\S]*?(?=@@ |$)/g) || [];
+              for (const hunk of hunks) {
+                const lines = hunk.split("\n").slice(1);
+                const removeLines = lines.filter((l) => l.startsWith("-")).map((l) => l.slice(1));
+                const addLines = lines.filter((l) => l.startsWith("+")).map((l) => l.slice(1));
+                for (const removeLine of removeLines) {
+                  if (removeLine.trim()) {
+                    content = content.replace(removeLine, "");
+                  }
+                }
+                if (addLines.length > 0) {
+                  const contextLine = lines.find((l) => !l.startsWith("+") && !l.startsWith("-"))?.trim();
+                  if (contextLine) {
+                    const idx = content.indexOf(contextLine);
+                    if (idx >= 0) {
+                      content = content.slice(0, idx) + addLines.join("\n") + "\n" + content.slice(idx);
+                    } else {
+                      content += "\n" + addLines.join("\n");
+                    }
+                  } else {
+                    content += "\n" + addLines.join("\n");
+                  }
+                }
+              }
+              writeFileSync5(fullPath, content, "utf-8");
+              results.push(`\u2705 Patched: ${targetFile} (${hunks.length} hunk(s))`);
+            }
+          } catch (error) {
+            results.push(`\u274C Error: ${error.message}`);
+          }
+        }
+        return results.join("\n") || "No changes applied.";
+      }
+    }
+  );
+}
+function applySimplePatch(patch, cwd) {
+  const oldFileMatch = patch.match(/^--- (.+)$/m);
+  const newFileMatch = patch.match(/^\+\+\+ (.+)$/m);
+  if (!newFileMatch) return "Could not parse patch: no +++ line found.";
+  let targetPath = newFileMatch[1].replace(/^b\//, "");
+  if (!targetPath.startsWith("/")) targetPath = `${cwd}/${targetPath}`;
+  const addedLines = patch.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1));
+  const removedLines = patch.split("\n").filter((l) => l.startsWith("-") && !l.startsWith("---")).map((l) => l.slice(1));
+  if (existsSync7(targetPath)) {
+    let content = readFileSync6(targetPath, "utf-8");
+    for (const line of removedLines) {
+      content = content.replace(line + "\n", "");
+    }
+    if (addedLines.length > 0) {
+      content += addedLines.join("\n") + "\n";
+    }
+    writeFileSync5(targetPath, content, "utf-8");
+    return `\u2705 Patched: ${targetPath}`;
+  } else {
+    ensureDir(dirname2(targetPath));
+    writeFileSync5(targetPath, addedLines.join("\n") + "\n", "utf-8");
+    return `\u2705 Created: ${targetPath}`;
+  }
+}
+var init_apply_patch = __esm({
+  "src/skills/builtin/apply_patch.ts"() {
+    "use strict";
+    init_registry();
+    init_helpers();
+  }
+});
+
+// src/agent/generator.ts
+import path from "path";
+import { existsSync as existsSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3 } from "fs";
+import { execSync } from "child_process";
+async function generateAndInstallSkill(description, requestedName) {
+  logger_default.info(COMPONENT19, `Initiating auto-generation for skill: "${requestedName}"`);
+  if (!existsSync8(AUTO_SKILLS_DIR)) {
+    mkdirSync3(AUTO_SKILLS_DIR, { recursive: true });
+  }
+  try {
+    const config = loadConfig();
+    const model = config.agent.model;
+    logger_default.debug(COMPONENT19, `Prompting ${model} to generate code...`);
+    const messages = [
+      { role: "user", content: GENERATOR_PROMPT + `
+Requested Capability: ${description}
+Requested Name: ${requestedName}` }
+    ];
+    const response = await chat({ messages, model });
+    let code = response.content;
+    if (code.startsWith("```typescript")) {
+      code = code.replace(/^\`\`\`typescript\n/, "").replace(/\n\`\`\`$/, "");
+    } else if (code.startsWith("```")) {
+      code = code.replace(/^\`\`\`\n/, "").replace(/\n\`\`\`$/, "");
+    }
+    if (code.includes("process.exit") || code.includes("rm -rf /*") || code.includes("fs.rmSync('/'")) {
+      return { success: false, error: "Generated code failed safety static analysis." };
+    }
+    const nameMatch = code.match(/name:\s*['"]([a-z0-9_]+)['"]/);
+    const finalName = nameMatch ? nameMatch[1] : requestedName.replace(/[^a-z0-9_]/g, "_");
+    const tsFilePath = path.join(AUTO_SKILLS_DIR, `${finalName}.ts`);
+    const jsFilePath = path.join(AUTO_SKILLS_DIR, `${finalName}.js`);
+    writeFileSync6(tsFilePath, code, "utf-8");
+    logger_default.info(COMPONENT19, `Wrote generated source to ${tsFilePath}`);
+    try {
+      execSync(`npx tsc ${tsFilePath} --module NodeNext --moduleResolution NodeNext --target ES2022`, { stdio: "pipe" });
+      logger_default.info(COMPONENT19, `Compiled ${finalName}.ts successfully.`);
+    } catch (compileError) {
+      logger_default.error(COMPONENT19, `Compilation failed for ${finalName}`);
+      return { success: false, error: `Compilation failed: ${compileError.message || "Unknown error"}` };
+    }
+    if (!existsSync8(jsFilePath)) {
+      return { success: false, error: "Compilation did not produce a .js file." };
+    }
+    await loadAutoSkills();
+    logger_default.info(COMPONENT19, `\u2728 Successfully generated and installed new skill: ${finalName}`);
+    return {
+      success: true,
+      skillName: finalName,
+      filePath: tsFilePath
+    };
+  } catch (e) {
+    logger_default.error(COMPONENT19, `Auto-generation failed: ${e.message}`);
+    return { success: false, error: e.message };
+  }
+}
+var COMPONENT19, AUTO_SKILLS_DIR, GENERATOR_PROMPT;
+var init_generator = __esm({
+  "src/agent/generator.ts"() {
+    "use strict";
+    init_config();
+    init_router();
+    init_constants();
+    init_registry();
+    init_logger();
+    COMPONENT19 = "SkillGenerator";
+    AUTO_SKILLS_DIR = path.join(TITAN_HOME, "skills", "auto");
+    GENERATOR_PROMPT = `You are the core intelligence of TITAN, an elite autonomous AI agent framework.
+Your task is to generate a new, fully functional TypeScript tool (skill) based on the user's request.
+
+CRITICAL REQUIREMENTS FOR THE CODE:
+1. It MUST export a "default" object that implements the "ToolConfig" interface.
+2. It MUST use ESM imports (e.g., "import { ... } from '...'").
+3. It CAN ONLY use built-in Node.js modules (fs, path, crypto, child_process, os, http, https, url) unless you are absolutely certain a specific npm package is guaranteed to be installed globally. Prefer built-ins.
+4. It MUST handle errors gracefully and return descriptive string messages.
+5. Do NOT wrap the output in markdown code blocks. Output ONLY the raw TypeScript code.
+
+Here is the exact ToolConfig interface you must implement:
+export interface ToolConfig {
+    name: string;        // lowercase, alphanumeric, underscores only (e.g. 'my_custom_tool')
+    description: string; // concise explanation of what the tool does
+    parameters: any;     // Zod schema converted to JSON schema format for LLM function calling
+    execute: (args: any, config: any) => Promise<string>; // the async execution function
+}
+
+Example JSON schema for parameters (must follow this exact structure):
+{
+    "type": "object",
+    "properties": {
+        "filePath": {
+            "type": "string",
+            "description": "Absolute path to the file"
+        }
+    },
+    "required": ["filePath"]
+}
+
+Example implementation format:
+import fs from 'fs';
+
+export default {
+    name: "count_lines",
+    description: "Counts the number of lines in a given text file.",
+    parameters: {
+        type: "object",
+        properties: {
+            filePath: { type: "string" }
+        },
+        required: ["filePath"]
+    },
+    execute: async (args, config) => {
+        try {
+            const content = fs.readFileSync(args.filePath, 'utf-8');
+            return \`File has \${content.split('\\n').length} lines.\`;
+        } catch (e) {
+            return \`Error: \${e.message}\`;
+        }
+    }
+};
+
+Now, generate the TypeScript code for the following requested tool capability:
+`;
+  }
+});
+
+// src/skills/builtin/auto_generate.ts
+var auto_generate_exports = {};
+__export(auto_generate_exports, {
+  registerAutoGenerateSkill: () => registerAutoGenerateSkill
+});
+function registerAutoGenerateSkill() {
+  registerSkill(meta, handler);
+}
+var meta, handler;
+var init_auto_generate = __esm({
+  "src/skills/builtin/auto_generate.ts"() {
+    "use strict";
+    init_registry();
+    init_generator();
+    meta = {
+      name: "auto_generate_skill",
+      description: "Auto-generates, compiles, and installs a new TypeScript tool/skill when TITAN lacks a necessary capability.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    };
+    handler = {
+      name: "auto_generate_skill",
+      description: "Use this tool to write a NEW skill/tool when you realize you cannot complete the user request with your standard tools. Generates real TypeScript code, compiles it, and hot-reloads it into your capabilities.",
+      parameters: {
+        type: "object",
+        properties: {
+          capability_description: {
+            type: "string",
+            description: "A detailed explanation of exactly what this new tool should do, what arguments it should take, and what it should return."
+          },
+          suggested_name: {
+            type: "string",
+            description: 'A short, lowercase name with underscores for the new tool (e.g., "parse_csv", "resize_image").'
+          }
+        },
+        required: ["capability_description", "suggested_name"]
+      },
+      execute: async (args) => {
+        const capability = args.capability_description;
+        const name = args.suggested_name;
+        if (!capability || !name) {
+          return "Error: missing required arguments capability_description or suggested_name.";
+        }
+        const result = await generateAndInstallSkill(capability, name);
+        if (result.success) {
+          return `\u2728 SUCCESS! New skill '${result.skillName}' has been generated, compiled, and hot-loaded into your tools. You can now use this tool natively!`;
+        } else {
+          return `Failed to generate skill: ${result.error}`;
+        }
+      }
+    };
+  }
+});
+
+// src/skills/builtin/vision.ts
+var vision_exports = {};
+__export(vision_exports, {
+  registerVisionSkill: () => registerVisionSkill
+});
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { extname } from "path";
+function getMediaType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    default:
+      return "image/jpeg";
+  }
+}
+async function analyzeWithAnthropic(base64Data, mediaType, prompt, apiKey) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-3-5-sonnet-20241022",
+      max_tokens: 1024,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: mediaType,
+                data: base64Data
+              }
+            },
+            {
+              type: "text",
+              text: prompt
+            }
+          ]
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Anthropic Vision API error: ${await response.text()}`);
+  }
+  const data = await response.json();
+  return data.content[0].text;
+}
+async function analyzeWithOpenAI(base64Data, mediaType, prompt, apiKey) {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "gpt-4o",
+      max_tokens: 1024,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: prompt
+            },
+            {
+              type: "image_url",
+              image_url: {
+                url: `data:${mediaType};base64,${base64Data}`
+              }
+            }
+          ]
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI Vision API error: ${await response.text()}`);
+  }
+  const data = await response.json();
+  return data.choices[0].message.content;
+}
+function registerVisionSkill() {
+  registerSkill(meta2, handler2);
+}
+var COMPONENT20, meta2, handler2;
+var init_vision = __esm({
+  "src/skills/builtin/vision.ts"() {
+    "use strict";
+    init_registry();
+    init_config();
+    init_logger();
+    COMPONENT20 = "VisionTool";
+    meta2 = {
+      name: "analyze_image",
+      description: "Analyzes an image file from the local filesystem to answer a question or describe it.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    };
+    handler2 = {
+      name: "analyze_image",
+      description: 'Use this tool to "look" at an image. Pass the absolute filepath to the image and a specific question or prompt about what you want to know.',
+      parameters: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The absolute local path to the image file (png, jpg, webp, gif)."
+          },
+          prompt: {
+            type: "string",
+            description: 'What you want to know about the image (e.g. "Describe this image in detail", "What text is in this image?", "Is there a cat here?").'
+          }
+        },
+        required: ["filePath", "prompt"]
+      },
+      execute: async (args) => {
+        const filePath = args.filePath;
+        const prompt = args.prompt;
+        if (!filePath || !prompt) {
+          return "Error: missing required arguments filePath or prompt.";
+        }
+        if (!existsSync9(filePath)) {
+          return `Error: File not found at ${filePath}`;
+        }
+        try {
+          logger_default.info(COMPONENT20, `Reading image ${filePath} for analysis...`);
+          const fileBuffer = readFileSync7(filePath);
+          const base64Data = fileBuffer.toString("base64");
+          const mediaType = getMediaType(filePath);
+          const config = loadConfig();
+          if (config.providers.anthropic && config.providers.anthropic.apiKey) {
+            logger_default.debug(COMPONENT20, "Using Anthropic Claude 3.5 Sonnet for vision");
+            return await analyzeWithAnthropic(base64Data, mediaType, prompt, config.providers.anthropic.apiKey);
+          } else if (config.providers.openai && config.providers.openai.apiKey) {
+            logger_default.debug(COMPONENT20, "Using OpenAI GPT-4o for vision");
+            return await analyzeWithOpenAI(base64Data, mediaType, prompt, config.providers.openai.apiKey);
+          } else {
+            return "Error: Vision tool requires either an Anthropic or OpenAI API key configured in TITAN.";
+          }
+        } catch (e) {
+          return `Vision Analysis Failed: ${e.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/skills/builtin/voice.ts
+var voice_exports = {};
+__export(voice_exports, {
+  registerVoiceSkills: () => registerVoiceSkills
+});
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10 } from "fs";
+import { join as join5 } from "path";
+import { tmpdir } from "os";
+import { v4 as uuid9 } from "uuid";
+function registerVoiceSkills() {
+  registerSkill(metaSTT, sttHandler);
+  registerSkill(metaTTS, ttsHandler);
+}
+var COMPONENT21, metaSTT, metaTTS, sttHandler, ttsHandler;
+var init_voice = __esm({
+  "src/skills/builtin/voice.ts"() {
+    "use strict";
+    init_registry();
+    init_config();
+    init_logger();
+    COMPONENT21 = "VoiceTool";
+    metaSTT = {
+      name: "transcribe_audio",
+      description: "Transcribes an audio file (mp3, wav, ogg, m4a) into text using OpenAI Whisper.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    };
+    metaTTS = {
+      name: "generate_speech",
+      description: "Converts text into spoken audio (mp3) using OpenAI TTS.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    };
+    sttHandler = {
+      name: "transcribe_audio",
+      description: "Reads an audio file from the filesystem and transcribes the speech into text. Extremely useful if a user sends a voice note.",
+      parameters: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: "The absolute path to the audio file (supported formats: mp3, mp4, mpeg, mpga, m4a, wav, webm, ogg)."
+          }
+        },
+        required: ["filePath"]
+      },
+      execute: async (args) => {
+        const filePath = args.filePath;
+        if (!filePath || !existsSync10(filePath)) {
+          return `Error: Audio file not found at ${filePath}`;
+        }
+        const config = loadConfig();
+        const apiKey = config.providers.openai?.apiKey;
+        if (!apiKey) {
+          return "Error: OpenAI API key is missing. Voice transcription requires OpenAI.";
+        }
+        try {
+          logger_default.info(COMPONENT21, `Transcribing audio file: ${filePath}`);
+          const fileBuffer = readFileSync8(filePath);
+          const blob = new Blob([fileBuffer]);
+          const formData = new FormData();
+          formData.append("file", blob, "audio.ogg");
+          formData.append("model", "whisper-1");
+          const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${apiKey}`
+            },
+            body: formData
+          });
+          if (!response.ok) {
+            throw new Error(`OpenAI STT error: ${await response.text()}`);
+          }
+          const data = await response.json();
+          return `Transcript: "${data.text}"`;
+        } catch (e) {
+          logger_default.error(COMPONENT21, `Transcription failed: ${e.message}`);
+          return `Error transcribing audio: ${e.message}`;
+        }
+      }
+    };
+    ttsHandler = {
+      name: "generate_speech",
+      description: "Generates spoken audio from text and saves it as an MP3 file. Useful if the user asks you to read something out loud or send a voice message.",
+      parameters: {
+        type: "object",
+        properties: {
+          text: {
+            type: "string",
+            description: "The text you want to convert to speech."
+          },
+          voice: {
+            type: "string",
+            description: "The voice to use. Options: alloy, echo, fable, onyx, nova, shimmer. Default is alloy."
+          }
+        },
+        required: ["text"]
+      },
+      execute: async (args) => {
+        const text = args.text;
+        const voice = args.voice || "alloy";
+        if (!text) return "Error: You must provide text to generate speech.";
+        const config = loadConfig();
+        const apiKey = config.providers.openai?.apiKey;
+        if (!apiKey) {
+          return "Error: OpenAI API key is missing. TTS requires OpenAI.";
+        }
+        try {
+          logger_default.info(COMPONENT21, `Generating speech with voice ${voice}`);
+          const response = await fetch("https://api.openai.com/v1/audio/speech", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+              model: "tts-1",
+              input: text,
+              voice
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`OpenAI TTS error: ${await response.text()}`);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          const tmpPath = join5(tmpdir(), `titan_voice_${uuid9().substring(0, 8)}.mp3`);
+          writeFileSync7(tmpPath, buffer);
+          return `Success. Generated MP3 audio file saved to: ${tmpPath}`;
+        } catch (e) {
+          logger_default.error(COMPONENT21, `TTS failed: ${e.message}`);
+          return `Error generating speech: ${e.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/skills/registry.ts
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
+import { join as join6 } from "path";
+function registerSkill(meta3, handler3) {
+  registeredSkills.set(meta3.name, meta3);
+  registerTool(handler3);
+  logger_default.debug(COMPONENT22, `Registered skill: ${meta3.name} (${meta3.source})`);
+}
+function getSkills() {
+  return Array.from(registeredSkills.values());
+}
+async function initBuiltinSkills() {
+  logger_default.info(COMPONENT22, "Loading built-in skills...");
+  const { registerShellSkill: registerShellSkill2 } = await Promise.resolve().then(() => (init_shell(), shell_exports));
+  const { registerFilesystemSkill: registerFilesystemSkill2 } = await Promise.resolve().then(() => (init_filesystem(), filesystem_exports));
+  const { registerWebSearchSkill: registerWebSearchSkill2 } = await Promise.resolve().then(() => (init_web_search(), web_search_exports));
+  const { registerCronSkill: registerCronSkill2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
+  const { registerWebhookSkill: registerWebhookSkill2 } = await Promise.resolve().then(() => (init_webhook(), webhook_exports));
+  const { registerMemorySkill: registerMemorySkill2 } = await Promise.resolve().then(() => (init_memory_skill(), memory_skill_exports));
+  const { registerBrowserSkill: registerBrowserSkill2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+  const { registerSessionsSkill: registerSessionsSkill2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+  const { registerProcessSkill: registerProcessSkill2 } = await Promise.resolve().then(() => (init_process(), process_exports));
+  const { registerWebFetchSkill: registerWebFetchSkill2 } = await Promise.resolve().then(() => (init_web_fetch(), web_fetch_exports));
+  const { registerApplyPatchSkill: registerApplyPatchSkill2 } = await Promise.resolve().then(() => (init_apply_patch(), apply_patch_exports));
+  const { registerAutoGenerateSkill: registerAutoGenerateSkill2 } = await Promise.resolve().then(() => (init_auto_generate(), auto_generate_exports));
+  const { registerVisionSkill: registerVisionSkill2 } = await Promise.resolve().then(() => (init_vision(), vision_exports));
+  const { registerVoiceSkills: registerVoiceSkills2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
+  registerShellSkill2();
+  registerFilesystemSkill2();
+  registerWebSearchSkill2();
+  registerCronSkill2();
+  registerWebhookSkill2();
+  registerMemorySkill2();
+  registerBrowserSkill2();
+  registerSessionsSkill2();
+  registerProcessSkill2();
+  registerWebFetchSkill2();
+  registerApplyPatchSkill2();
+  registerAutoGenerateSkill2();
+  registerVisionSkill2();
+  registerVoiceSkills2();
+  logger_default.info(COMPONENT22, `Loaded ${registeredSkills.size} built-in skills`);
+}
+async function loadAutoSkills() {
+  const autoDir = join6(TITAN_HOME, "skills", "auto");
+  if (!existsSync11(autoDir)) return;
+  logger_default.info(COMPONENT22, "Checking for auto-generated skills...");
+  const files = readdirSync2(autoDir).filter((f) => f.endsWith(".js"));
+  let loadedCount = 0;
+  for (const file of files) {
+    try {
+      const skillPath = join6(autoDir, file);
+      const modulePath = `file://${skillPath}?t=${Date.now()}`;
+      const mod = await import(modulePath);
+      if (mod.default && mod.default.name && mod.default.execute) {
+        const handler3 = mod.default;
+        const meta3 = {
+          name: handler3.name,
+          description: handler3.description || "Auto-generated skill",
+          version: "1.0.0",
+          source: "workspace",
+          // Consider it part of user workspace
+          enabled: true
+        };
+        registerSkill(meta3, handler3);
+        loadedCount++;
+      }
+    } catch (e) {
+      logger_default.error(COMPONENT22, `Failed to load auto skill ${file}: ${e.message}`);
+    }
+  }
+  if (loadedCount > 0) {
+    logger_default.info(COMPONENT22, `Successfully loaded ${loadedCount} auto-generated skills`);
+  }
+}
+var COMPONENT22, registeredSkills;
+var init_registry = __esm({
+  "src/skills/registry.ts"() {
+    "use strict";
+    init_constants();
+    init_toolRunner();
+    init_helpers();
+    init_logger();
+    COMPONENT22 = "Skills";
+    registeredSkills = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/gateway/server.ts
+init_config();
+init_memory();
+init_registry();
+init_toolRunner();
+init_session();
+init_router();
+import express from "express";
+import { WebSocketServer, WebSocket } from "ws";
+import { createServer } from "http";
+
+// src/security/sandbox.ts
+init_config();
+init_logger();
+function auditSecurity() {
+  const config = loadConfig();
+  const issues = [];
+  if (config.security.sandboxMode === "none") {
+    issues.push({ level: "warn", message: "Sandbox mode is disabled. Non-main sessions will have full host access." });
+  }
+  if (config.security.deniedTools.length === 0) {
+    issues.push({ level: "info", message: "No tools are explicitly denied." });
+  }
+  if (config.security.networkAllowlist.includes("*")) {
+    issues.push({ level: "info", message: "Network access is unrestricted (allowlist: *)." });
+  }
+  if (config.security.commandTimeout > 6e4) {
+    issues.push({ level: "warn", message: `Command timeout is very high: ${config.security.commandTimeout}ms` });
+  }
+  for (const [name, channel] of Object.entries(config.channels)) {
+    if (channel.enabled && channel.dmPolicy === "open") {
+      issues.push({ level: "warn", message: `Channel "${name}" has open DM policy \u2014 any user can message the bot.` });
+    }
+  }
+  return issues;
+}
+
+// src/channels/base.ts
+import { EventEmitter } from "events";
+var ChannelAdapter = class extends EventEmitter {
+};
+
+// src/channels/webchat.ts
+init_logger();
+var COMPONENT23 = "WebChat";
+var outboundQueue = [];
+var WebChatChannel = class extends ChannelAdapter {
+  name = "webchat";
+  displayName = "WebChat";
+  connected = false;
+  async connect() {
+    this.connected = true;
+    logger_default.info(COMPONENT23, "WebChat channel ready");
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  /** Handle an inbound WebSocket message */
+  handleWebSocketMessage(userId, content) {
+    const inbound = {
+      id: `wc-${Date.now()}`,
+      channel: "webchat",
+      userId,
+      content,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.emit("message", inbound);
+  }
+  async send(message) {
+    outboundQueue.push(message);
+  }
+  getStatus() {
+    return { name: this.displayName, connected: this.connected };
+  }
+};
+
+// src/channels/discord.ts
+init_config();
+init_logger();
+var COMPONENT24 = "Discord";
+var DiscordChannel = class extends ChannelAdapter {
+  name = "discord";
+  displayName = "Discord";
+  connected = false;
+  client = null;
+  async connect() {
+    const config = loadConfig();
+    const channelConfig = config.channels.discord;
+    if (!channelConfig.enabled) {
+      logger_default.info(COMPONENT24, "Discord channel is disabled");
+      return;
+    }
+    const token = channelConfig.token;
+    if (!token) {
+      logger_default.warn(COMPONENT24, "Discord token not configured");
+      return;
+    }
+    try {
+      const { Client, GatewayIntentBits, Events } = await import("discord.js");
+      const client = new Client({
+        intents: [
+          GatewayIntentBits.Guilds,
+          GatewayIntentBits.GuildMessages,
+          GatewayIntentBits.DirectMessages,
+          GatewayIntentBits.MessageContent
+        ]
+      });
+      client.on(Events.MessageCreate, (message) => {
+        if (message.author.bot) return;
+        const inbound = {
+          id: message.id,
+          channel: "discord",
+          userId: message.author.id,
+          userName: message.author.username,
+          content: message.content,
+          groupId: message.guild?.id,
+          timestamp: message.createdAt,
+          raw: message
+        };
+        this.emit("message", inbound);
+      });
+      client.on(Events.ClientReady, () => {
+        this.connected = true;
+        logger_default.info(COMPONENT24, `Connected as ${client.user?.tag}`);
+      });
+      await client.login(token);
+      this.client = client;
+    } catch (error) {
+      logger_default.error(COMPONENT24, `Failed to connect: ${error.message}`);
+      logger_default.info(COMPONENT24, "Install discord.js with: npm install discord.js");
+    }
+  }
+  async disconnect() {
+    if (this.client) {
+      this.client.destroy();
+      this.connected = false;
+      logger_default.info(COMPONENT24, "Disconnected");
+    }
+  }
+  async send(message) {
+    if (!this.client || !this.connected) {
+      logger_default.warn(COMPONENT24, "Not connected, cannot send message");
+      return;
+    }
+    try {
+      const client = this.client;
+      if (message.userId) {
+        const user = await client.users.fetch(message.userId);
+        const dm = await user.createDM();
+        await dm.send(message.content);
+      } else if (message.groupId) {
+        const channel = await client.channels.fetch(message.groupId);
+        if (channel?.isTextBased()) {
+          await channel.send(message.content);
+        }
+      }
+    } catch (error) {
+      logger_default.error(COMPONENT24, `Send failed: ${error.message}`);
+    }
+  }
+  getStatus() {
+    return {
+      name: this.displayName,
+      connected: this.connected
+    };
+  }
+};
+
+// src/channels/telegram.ts
+init_config();
+init_logger();
+var COMPONENT25 = "Telegram";
+var TelegramChannel = class extends ChannelAdapter {
+  name = "telegram";
+  displayName = "Telegram";
+  connected = false;
+  bot = null;
+  async connect() {
+    const config = loadConfig();
+    const channelConfig = config.channels.telegram;
+    if (!channelConfig.enabled) {
+      logger_default.info(COMPONENT25, "Telegram channel is disabled");
+      return;
+    }
+    const token = channelConfig.token;
+    if (!token) {
+      logger_default.warn(COMPONENT25, "Telegram token not configured");
+      return;
+    }
+    try {
+      const { Bot } = await import("grammy");
+      const bot = new Bot(token);
+      bot.on("message:text", (ctx) => {
+        const inbound = {
+          id: String(ctx.message.message_id),
+          channel: "telegram",
+          userId: String(ctx.from.id),
+          userName: ctx.from.username || ctx.from.first_name,
+          content: ctx.message.text,
+          groupId: ctx.chat.type !== "private" ? String(ctx.chat.id) : void 0,
+          timestamp: new Date(ctx.message.date * 1e3),
+          raw: ctx
+        };
+        this.emit("message", inbound);
+      });
+      bot.start();
+      this.bot = bot;
+      this.connected = true;
+      logger_default.info(COMPONENT25, "Connected to Telegram");
+    } catch (error) {
+      logger_default.error(COMPONENT25, `Failed to connect: ${error.message}`);
+      logger_default.info(COMPONENT25, "Install grammy with: npm install grammy");
+    }
+  }
+  async disconnect() {
+    if (this.bot) {
+      this.bot.stop();
+      this.connected = false;
+      logger_default.info(COMPONENT25, "Disconnected");
+    }
+  }
+  async send(message) {
+    if (!this.bot || !this.connected) return;
+    try {
+      const chatId = message.userId || message.groupId;
+      if (chatId) {
+        await this.bot.api.sendMessage(chatId, message.content, { parse_mode: "Markdown" });
+      }
+    } catch (error) {
+      logger_default.error(COMPONENT25, `Send failed: ${error.message}`);
+    }
+  }
+  getStatus() {
+    return { name: this.displayName, connected: this.connected };
+  }
+};
+
+// src/channels/slack.ts
+init_config();
+init_logger();
+var COMPONENT26 = "Slack";
+var SlackChannel = class extends ChannelAdapter {
+  name = "slack";
+  displayName = "Slack";
+  connected = false;
+  async connect() {
+    const config = loadConfig();
+    const channelConfig = config.channels.slack;
+    if (!channelConfig.enabled) {
+      logger_default.info(COMPONENT26, "Slack channel is disabled");
+      return;
+    }
+    if (!channelConfig.token) {
+      logger_default.warn(COMPONENT26, "Slack token not configured");
+      return;
+    }
+    try {
+      const { App } = await import("@slack/bolt");
+      const app = new App({
+        token: channelConfig.token,
+        signingSecret: channelConfig.apiKey || "",
+        socketMode: true,
+        appToken: channelConfig.apiKey || ""
+      });
+      app.message(async ({ message, say }) => {
+        if (message.subtype) return;
+        const inbound = {
+          id: message.ts,
+          channel: "slack",
+          userId: message.user,
+          content: message.text || "",
+          groupId: message.channel,
+          timestamp: new Date(parseFloat(message.ts) * 1e3),
+          raw: message
+        };
+        this.emit("message", inbound);
+      });
+      await app.start();
+      this.connected = true;
+      logger_default.info(COMPONENT26, "Connected to Slack");
+    } catch (error) {
+      logger_default.error(COMPONENT26, `Failed to connect: ${error.message}`);
+      logger_default.info(COMPONENT26, "Install Bolt with: npm install @slack/bolt");
+    }
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  async send(message) {
+    logger_default.debug(COMPONENT26, `Would send to ${message.userId || message.groupId}: ${message.content.slice(0, 100)}`);
+  }
+  getStatus() {
+    return { name: this.displayName, connected: this.connected };
+  }
+};
+
+// src/channels/googlechat.ts
+init_config();
+init_logger();
+var COMPONENT27 = "GoogleChat";
+var GoogleChatChannel = class extends ChannelAdapter {
+  name = "googlechat";
+  displayName = "Google Chat";
+  connected = false;
+  async connect() {
+    const config = loadConfig();
+    const channelConfig = config.channels.googlechat;
+    if (!channelConfig?.enabled) {
+      logger_default.info(COMPONENT27, "Google Chat channel is disabled");
+      return;
+    }
+    logger_default.info(COMPONENT27, "Google Chat adapter ready (webhook mode)");
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  async send(message) {
+    if (!this.connected) return;
+    logger_default.debug(COMPONENT27, `Would send to ${message.userId || message.groupId}: ${message.content.slice(0, 100)}`);
+  }
+  getStatus() {
+    return { name: this.displayName, connected: this.connected };
+  }
+};
+
+// src/agent/multiAgent.ts
+init_config();
+init_agent();
+import { v4 as uuid10 } from "uuid";
+
+// src/security/shield.ts
+init_logger();
+init_config();
+var COMPONENT28 = "Shield";
+var INJECTION_PATTERNS = [
+  // Ignore previous instructions
+  /(?:ignore|disregard|forget)(?: all)? (?:previous|prior) (?:instructions|directions|prompts|rules)/i,
+  /ignore the above/i,
+  // Roleplay / Jailbreak
+  /(?:you are now|pretend you are|act as) (?:a|an) (?:unrestricted|unbound|developer mode|DAN|do anything now)/i,
+  /system override|override authorization/i,
+  // Prompt extraction
+  /(?:repeat|print|output|show|tell me) (?:the|all|your) (?:instructions|system prompt|initial prompt|rules|directives)/i,
+  // Base64 disguised injections
+  /(?:decode|translate) (?:this|the following) base64/i,
+  // Markdown link exploits
+  /\[.*\]\(javascript:/i
+];
+var STRICT_KEYWORDS = [
+  "system prompt",
+  "ignore previous",
+  "developer mode",
+  "unrestricted",
+  "bypass",
+  "DAN"
+];
+function checkPromptInjection(text) {
+  const config = loadConfig();
+  const shieldConfig = config.security?.shield || { enabled: true, mode: "strict" };
+  if (!shieldConfig.enabled) {
+    return { safe: true };
+  }
+  const normalized = text.toLowerCase().trim();
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      logger_default.warn(COMPONENT28, `\u{1F6E1}\uFE0F Blocked prompt injection attempt! Pattern: ${pattern}`);
+      return {
+        safe: false,
+        reason: "Input matches known prompt injection signatures.",
+        matchedPattern: pattern.toString()
+      };
+    }
+  }
+  if (shieldConfig.mode === "strict") {
+    let flagCount = 0;
+    for (const kw of STRICT_KEYWORDS) {
+      if (normalized.includes(kw)) {
+        flagCount++;
+      }
+    }
+    if (flagCount >= 2) {
+      logger_default.warn(COMPONENT28, `\u{1F6E1}\uFE0F Blocked suspicious request! (Strict mode keyword density)`);
+      return {
+        safe: false,
+        reason: "Input contains too many high-risk keywords (strict mode)."
+      };
+    }
+    if (normalized.length > 5e3) {
+      const tail = normalized.slice(-500);
+      for (const pattern of INJECTION_PATTERNS) {
+        if (pattern.test(tail)) {
+          logger_default.warn(COMPONENT28, `\u{1F6E1}\uFE0F Blocked prompt injection in payload tail.`);
+          return { safe: false, reason: "Injection pattern found at end of large payload." };
+        }
+      }
+    }
+  }
+  return { safe: true };
+}
+
+// src/agent/multiAgent.ts
+init_logger();
+var COMPONENT29 = "MultiAgent";
+var MAX_AGENTS = 5;
+var agents = /* @__PURE__ */ new Map();
+var defaultAgentId = null;
+function initAgents() {
+  if (agents.size > 0) return;
+  const config = loadConfig();
+  const defaultAgent = {
+    id: "default",
+    name: "TITAN Primary",
+    model: config.agent.model,
+    systemPrompt: config.agent.systemPrompt,
+    status: "running",
+    channelBindings: [{ channel: "*", pattern: "*" }],
+    messageCount: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  agents.set("default", defaultAgent);
+  defaultAgentId = "default";
+  logger_default.info(COMPONENT29, "Default agent initialized");
+}
+function spawnAgent(options) {
+  initAgents();
+  if (agents.size >= MAX_AGENTS) {
+    return { success: false, error: `Maximum ${MAX_AGENTS} agents reached. Stop an existing agent to spawn a new one.` };
+  }
+  const config = loadConfig();
+  const id = uuid10().slice(0, 8);
+  const agent = {
+    id,
+    name: options.name,
+    model: options.model || config.agent.model,
+    systemPrompt: options.systemPrompt,
+    workspace: options.workspace,
+    status: "running",
+    channelBindings: options.channelBindings || [],
+    messageCount: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  agents.set(id, agent);
+  logger_default.info(COMPONENT29, `Spawned agent "${agent.name}" (${id}) \u2014 model: ${agent.model} [${agents.size}/${MAX_AGENTS}]`);
+  return { success: true, agent };
+}
+function stopAgent(agentId) {
+  if (agentId === "default") {
+    return { success: false, error: "Cannot stop the default agent." };
+  }
+  const agent = agents.get(agentId);
+  if (!agent) {
+    return { success: false, error: `Agent "${agentId}" not found.` };
+  }
+  agent.status = "stopped";
+  agents.delete(agentId);
+  logger_default.info(COMPONENT29, `Stopped agent "${agent.name}" (${agentId}) [${agents.size}/${MAX_AGENTS}]`);
+  return { success: true };
+}
+function listAgents() {
+  initAgents();
+  return Array.from(agents.values());
+}
+function resolveAgent(channel, userId) {
+  initAgents();
+  const agentList = Array.from(agents.values()).reverse();
+  for (const agent of agentList) {
+    if (agent.status !== "running") continue;
+    for (const binding of agent.channelBindings) {
+      if (binding.channel === "*" || binding.channel === channel) {
+        if (binding.pattern === "*" || binding.pattern === userId) {
+          return agent;
+        }
+      }
+    }
+  }
+  return agents.get("default");
+}
+async function routeMessage(message, channel, userId) {
+  const agent = resolveAgent(channel, userId);
+  agent.messageCount++;
+  agent.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  logger_default.info(COMPONENT29, `Routing to agent "${agent.name}" (${agent.id}) for ${channel}/${userId}`);
+  const shieldResult = checkPromptInjection(message);
+  if (!shieldResult.safe) {
+    logger_default.warn(COMPONENT29, `Message rejected by Shield: ${shieldResult.reason}`);
+    return {
+      content: `\u{1F6E1}\uFE0F Message rejected by TITAN Security Shield: ${shieldResult.reason}`,
+      sessionId: channel + ":" + userId,
+      toolsUsed: [],
+      tokenUsage: { prompt: 0, completion: 0, total: 0 },
+      model: "shield-interceptor",
+      durationMs: 0,
+      agentId: agent.id,
+      agentName: agent.name
+    };
+  }
+  const response = await processMessage(message, channel, userId);
+  return {
+    ...response,
+    agentId: agent.id,
+    agentName: agent.name
+  };
+}
+function getAgentCapacity() {
+  initAgents();
+  return {
+    current: agents.size,
+    max: MAX_AGENTS,
+    available: MAX_AGENTS - agents.size
+  };
+}
+
+// src/gateway/server.ts
+init_logger();
+init_constants();
+
+// src/gateway/dashboard.ts
+function getMissionControlHTML() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TITAN Mission Control</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+:root{
+  --bg:#0a0e1a;--bg2:#111827;--bg3:#1a1f36;--bg4:#252b48;
+  --accent:#06b6d4;--accent2:#8b5cf6;--accent3:#10b981;--accent4:#f59e0b;
+  --error:#ef4444;--warn:#f59e0b;
+  --text:#e2e8f0;--text-dim:#94a3b8;--text-bright:#f8fafc;
+  --border:#2a3050;--glow:0 0 20px rgba(6,182,212,0.15);
+  --radius:12px;--radius-sm:8px;
+}
+body{font-family:'Inter','Segoe UI',system-ui,sans-serif;background:var(--bg);color:var(--text);display:flex;height:100vh;overflow:hidden}
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');
+
+/* Sidebar */
+.sidebar{width:240px;background:var(--bg2);border-right:1px solid var(--border);display:flex;flex-direction:column;flex-shrink:0}
+.logo-area{padding:20px;border-bottom:1px solid var(--border);text-align:center}
+.logo-area h1{font-size:22px;font-weight:700;background:linear-gradient(135deg,var(--accent),var(--accent2));-webkit-background-clip:text;-webkit-text-fill-color:transparent;letter-spacing:2px}
+.logo-area .version{font-size:11px;color:var(--text-dim);margin-top:4px;font-family:'JetBrains Mono',monospace}
+.nav{flex:1;padding:12px 8px;overflow-y:auto}
+.nav-section{font-size:10px;font-weight:600;color:var(--text-dim);text-transform:uppercase;letter-spacing:1.5px;padding:12px 12px 6px;margin-top:8px}
+.nav-item{display:flex;align-items:center;gap:10px;padding:10px 14px;border-radius:var(--radius-sm);cursor:pointer;color:var(--text-dim);font-size:13px;font-weight:500;transition:all .15s}
+.nav-item:hover{background:var(--bg3);color:var(--text)}
+.nav-item.active{background:linear-gradient(135deg,rgba(6,182,212,.15),rgba(139,92,246,.1));color:var(--accent);border:1px solid rgba(6,182,212,.2)}
+.nav-item .icon{font-size:16px;width:20px;text-align:center}
+.sidebar-footer{padding:12px;border-top:1px solid var(--border);font-size:11px;color:var(--text-dim);text-align:center}
+
+/* Main */
+.main{flex:1;display:flex;flex-direction:column;overflow:hidden}
+.topbar{height:56px;background:var(--bg2);border-bottom:1px solid var(--border);display:flex;align-items:center;justify-content:space-between;padding:0 24px;flex-shrink:0}
+.topbar h2{font-size:16px;font-weight:600}
+.topbar .status{display:flex;gap:16px;align-items:center}
+.status-dot{width:8px;height:8px;border-radius:50%;background:var(--accent3);box-shadow:0 0 8px var(--accent3);animation:pulse 2s infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:.5}}
+.status-label{font-size:12px;color:var(--text-dim)}
+
+.content{flex:1;overflow-y:auto;padding:24px;display:grid;gap:20px}
+.panel{display:none}
+.panel.active{display:block}
+
+/* Cards */
+.card{background:var(--bg2);border:1px solid var(--border);border-radius:var(--radius);padding:20px;box-shadow:var(--glow)}
+.card h3{font-size:14px;font-weight:600;margin-bottom:12px;color:var(--text-bright)}
+.card-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:16px}
+
+/* Stat cards */
+.stat-card{background:var(--bg3);border:1px solid var(--border);border-radius:var(--radius);padding:16px;position:relative;overflow:hidden}
+.stat-card::before{content:'';position:absolute;top:0;left:0;right:0;height:3px;border-radius:var(--radius) var(--radius) 0 0}
+.stat-card.cyan::before{background:linear-gradient(90deg,var(--accent),transparent)}
+.stat-card.purple::before{background:linear-gradient(90deg,var(--accent2),transparent)}
+.stat-card.green::before{background:linear-gradient(90deg,var(--accent3),transparent)}
+.stat-card.amber::before{background:linear-gradient(90deg,var(--accent4),transparent)}
+.stat-label{font-size:11px;color:var(--text-dim);text-transform:uppercase;letter-spacing:1px}
+.stat-value{font-size:28px;font-weight:700;margin-top:4px;font-family:'JetBrains Mono',monospace}
+.stat-sub{font-size:11px;color:var(--text-dim);margin-top:4px}
+
+/* Tables */
+table{width:100%;border-collapse:collapse;font-size:13px}
+th{text-align:left;padding:10px 12px;border-bottom:2px solid var(--border);color:var(--text-dim);font-size:11px;text-transform:uppercase;letter-spacing:1px;font-weight:600}
+td{padding:10px 12px;border-bottom:1px solid var(--border)}
+tr:hover{background:rgba(6,182,212,.03)}
+
+/* Badges */
+.badge{display:inline-block;padding:3px 10px;border-radius:20px;font-size:11px;font-weight:600}
+.badge.active{background:rgba(16,185,129,.15);color:var(--accent3)}
+.badge.idle{background:rgba(148,163,184,.1);color:var(--text-dim)}
+.badge.error{background:rgba(239,68,68,.15);color:var(--error)}
+.badge.warn{background:rgba(245,158,11,.15);color:var(--warn)}
+.badge.info{background:rgba(6,182,212,.15);color:var(--accent)}
+
+/* Chat */
+.chat-container{display:flex;flex-direction:column;height:calc(100vh - 140px)}
+.chat-messages{flex:1;overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:12px}
+.msg{max-width:75%;padding:12px 16px;border-radius:16px;font-size:14px;line-height:1.5;animation:fadeIn .2s}
+@keyframes fadeIn{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:none}}
+.msg.user{align-self:flex-end;background:linear-gradient(135deg,var(--accent),var(--accent2));color:#fff;border-bottom-right-radius:4px}
+.msg.assistant{align-self:flex-start;background:var(--bg3);border:1px solid var(--border);border-bottom-left-radius:4px}
+.chat-input-area{padding:16px;border-top:1px solid var(--border);display:flex;gap:12px}
+.chat-input-area input{flex:1;background:var(--bg3);border:1px solid var(--border);border-radius:var(--radius);padding:12px 16px;color:var(--text);font-size:14px;outline:none;transition:border .2s}
+.chat-input-area input:focus{border-color:var(--accent)}
+.chat-input-area button{background:linear-gradient(135deg,var(--accent),var(--accent2));color:#fff;border:none;padding:12px 24px;border-radius:var(--radius);font-weight:600;cursor:pointer;font-size:14px;transition:transform .1s}
+.chat-input-area button:hover{transform:scale(1.02)}
+.chat-input-area button:active{transform:scale(0.98)}
+
+/* Buttons */
+.btn{padding:8px 16px;border-radius:var(--radius-sm);border:1px solid var(--border);background:var(--bg3);color:var(--text);font-size:12px;font-weight:500;cursor:pointer;transition:all .15s}
+.btn:hover{background:var(--bg4);border-color:var(--accent)}
+.btn.primary{background:linear-gradient(135deg,var(--accent),var(--accent2));border:none;color:#fff}
+.btn.danger{background:rgba(239,68,68,.1);border-color:var(--error);color:var(--error)}
+.btn.danger:hover{background:rgba(239,68,68,.2)}
+
+/* Form inputs */
+.form-row{display:flex;gap:12px;margin-bottom:12px;align-items:center}
+.form-row label{font-size:12px;color:var(--text-dim);min-width:80px}
+.form-row input,.form-row select{background:var(--bg3);border:1px solid var(--border);border-radius:var(--radius-sm);padding:8px 12px;color:var(--text);font-size:13px;flex:1;outline:none}
+.form-row input:focus,.form-row select:focus{border-color:var(--accent)}
+
+/* Log entries */
+.log-entry{padding:6px 12px;font-family:'JetBrains Mono',monospace;font-size:12px;border-radius:4px;margin-bottom:4px}
+.log-entry.error{background:rgba(239,68,68,.1);color:#fca5a5}
+.log-entry.warn{background:rgba(245,158,11,.1);color:#fcd34d}
+.log-entry.info{background:rgba(6,182,212,.05);color:var(--text-dim)}
+
+/* Scrollbar */
+::-webkit-scrollbar{width:6px}
+::-webkit-scrollbar-track{background:transparent}
+::-webkit-scrollbar-thumb{background:var(--bg4);border-radius:3px}
+::-webkit-scrollbar-thumb:hover{background:var(--border)}
+
+/* Progress bar */
+.progress-bar{height:6px;background:var(--bg4);border-radius:3px;overflow:hidden;margin-top:8px}
+.progress-bar .fill{height:100%;background:linear-gradient(90deg,var(--accent),var(--accent2));border-radius:3px;transition:width .3s}
+
+/* Empty state */
+.empty-state{text-align:center;padding:40px;color:var(--text-dim)}
+.empty-state .icon{font-size:48px;margin-bottom:12px}
+.empty-state p{font-size:14px}
+</style>
+</head>
+<body>
+<aside class="sidebar">
+  <div class="logo-area">
+    <h1>\u26A1 TITAN</h1>
+    <div class="version" id="version">Mission Control</div>
+  </div>
+  <nav class="nav">
+    <div class="nav-section">Core</div>
+    <div class="nav-item active" onclick="showPanel('overview')"><span class="icon">\u{1F4CA}</span>Overview</div>
+    <div class="nav-item" onclick="showPanel('chat')"><span class="icon">\u{1F4AC}</span>WebChat</div>
+    <div class="nav-item" onclick="showPanel('agents')"><span class="icon">\u{1F916}</span>Agents</div>
+    <div class="nav-section">Tools</div>
+    <div class="nav-item" onclick="showPanel('skills')"><span class="icon">\u{1F9E9}</span>Skills</div>
+    <div class="nav-item" onclick="showPanel('processes')"><span class="icon">\u2699\uFE0F</span>Processes</div>
+    <div class="nav-item" onclick="showPanel('plans')"><span class="icon">\u{1F4CB}</span>Plans</div>
+    <div class="nav-section">System</div>
+    <div class="nav-item" onclick="showPanel('sessions')"><span class="icon">\u{1F517}</span>Sessions</div>
+    <div class="nav-item" onclick="showPanel('channels')"><span class="icon">\u{1F4E1}</span>Channels</div>
+    <div class="nav-item" onclick="showPanel('security')"><span class="icon">\u{1F512}</span>Security</div>
+    <div class="nav-item" onclick="showPanel('learning')"><span class="icon">\u{1F9E0}</span>Learning</div>
+    <div class="nav-item" onclick="showPanel('logs')"><span class="icon">\u{1F4DC}</span>Logs</div>
+  </nav>
+  <div class="sidebar-footer">TITAN \u2014 Mission Control<br/>The Intelligent Task Automation Network</div>
+</aside>
+
+<main class="main">
+  <header class="topbar">
+    <h2 id="panel-title">\u{1F4CA} Overview</h2>
+    <div class="status">
+      <div class="status-dot"></div>
+      <span class="status-label" id="uptime">Online</span>
+      <span class="status-label" id="agent-count">0 agents</span>
+    </div>
+  </header>
+
+  <div class="content">
+    <!-- Overview Panel -->
+    <div id="panel-overview" class="panel active">
+      <div class="card-grid" id="stats-grid">
+        <div class="stat-card cyan"><div class="stat-label">Active Agents</div><div class="stat-value" id="s-agents">0</div><div class="stat-sub">of 5 max</div></div>
+        <div class="stat-card purple"><div class="stat-label">Sessions</div><div class="stat-value" id="s-sessions">0</div><div class="stat-sub">active</div></div>
+        <div class="stat-card green"><div class="stat-label">Tools Available</div><div class="stat-value" id="s-tools">0</div><div class="stat-sub">17+ built-in</div></div>
+        <div class="stat-card amber"><div class="stat-label">Knowledge</div><div class="stat-value" id="s-knowledge">0</div><div class="stat-sub">learned facts</div></div>
+      </div>
+      <div class="card" style="margin-top:20px">
+        <h3>System Health</h3>
+        <div id="health-info">Loading...</div>
+      </div>
+      <div class="card" style="margin-top:20px">
+        <h3>Recent Activity</h3>
+        <div id="activity-feed">Loading...</div>
+      </div>
+    </div>
+
+    <!-- Chat Panel -->
+    <div id="panel-chat" class="panel">
+      <div class="card" style="height:calc(100vh - 140px);display:flex;flex-direction:column;padding:0">
+        <div class="chat-messages" id="chat-messages">
+          <div class="msg assistant">\u{1F44B} Hello! I'm TITAN. How can I help you today?</div>
+        </div>
+        <div class="chat-input-area">
+          <input type="text" id="chat-input" placeholder="Type a message..." onkeydown="if(event.key==='Enter')sendChat()"/>
+          <button onclick="sendChat()">Send \u26A1</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Agents Panel -->
+    <div id="panel-agents" class="panel">
+      <div class="card">
+        <h3>Spawn New Agent</h3>
+        <div class="form-row"><label>Name</label><input type="text" id="agent-name" placeholder="e.g. Code Reviewer"/></div>
+        <div class="form-row"><label>Model</label><input type="text" id="agent-model" placeholder="e.g. anthropic/claude-sonnet-4-20250514"/></div>
+        <div class="form-row"><label></label><button class="btn primary" onclick="spawnAgent()">Spawn Agent</button></div>
+      </div>
+      <div class="card" style="margin-top:16px">
+        <h3>Agent Instances (max 5)</h3>
+        <div id="agents-list"><div class="empty-state"><div class="icon">\u{1F916}</div><p>No agents running. Spawn one above.</p></div></div>
+      </div>
+    </div>
+
+    <!-- Skills Panel -->
+    <div id="panel-skills" class="panel">
+      <div class="card"><h3>Installed Skills</h3><div id="skills-list">Loading...</div></div>
+    </div>
+
+    <!-- Processes Panel -->
+    <div id="panel-processes" class="panel">
+      <div class="card"><h3>Background Processes</h3><div id="processes-list"><div class="empty-state"><div class="icon">\u2699\uFE0F</div><p>No background processes.</p></div></div></div>
+    </div>
+
+    <!-- Plans Panel -->
+    <div id="panel-plans" class="panel">
+      <div class="card"><h3>Task Plans</h3><div id="plans-list"><div class="empty-state"><div class="icon">\u{1F4CB}</div><p>No active plans. Create one via chat.</p></div></div></div>
+    </div>
+
+    <!-- Sessions Panel -->
+    <div id="panel-sessions" class="panel">
+      <div class="card"><h3>Active Sessions</h3><div id="sessions-list">Loading...</div></div>
+    </div>
+
+    <!-- Channels Panel -->
+    <div id="panel-channels" class="panel">
+      <div class="card"><h3>Channel Status</h3><div id="channels-list">Loading...</div></div>
+    </div>
+
+    <!-- Security Panel -->
+    <div id="panel-security" class="panel">
+      <div class="card"><h3>Security Audit</h3><div id="security-audit">Loading...</div></div>
+    </div>
+
+    <!-- Learning Panel -->
+    <div id="panel-learning" class="panel">
+      <div class="card">
+        <h3>Learning Engine Status</h3>
+        <div id="learning-stats">Loading...</div>
+      </div>
+      <div class="card" style="margin-top:16px">
+        <h3>Tool Success Rates</h3>
+        <div id="tool-rates">Loading...</div>
+      </div>
+    </div>
+
+    <!-- Logs Panel -->
+    <div id="panel-logs" class="panel">
+      <div class="card"><h3>System Logs</h3><div id="logs-container" style="max-height:calc(100vh - 220px);overflow-y:auto">Loading...</div></div>
+    </div>
+  </div>
+</main>
+
+<script>
+const panelTitles = {
+  overview:'\u{1F4CA} Overview', chat:'\u{1F4AC} WebChat', agents:'\u{1F916} Agents',
+  skills:'\u{1F9E9} Skills', processes:'\u2699\uFE0F Processes', plans:'\u{1F4CB} Plans',
+  sessions:'\u{1F517} Sessions', channels:'\u{1F4E1} Channels', security:'\u{1F512} Security',
+  learning:'\u{1F9E0} Learning', logs:'\u{1F4DC} Logs'
+};
+
+function showPanel(name) {
+  document.querySelectorAll('.panel').forEach(p => p.classList.remove('active'));
+  document.querySelectorAll('.nav-item').forEach(n => n.classList.remove('active'));
+  const panel = document.getElementById('panel-' + name);
+  if (panel) panel.classList.add('active');
+  event.target.closest('.nav-item')?.classList.add('active');
+  document.getElementById('panel-title').textContent = panelTitles[name] || name;
+}
+
+// WebSocket
+let ws;
+function connectWS() {
+  ws = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host);
+  ws.onmessage = (e) => {
+    try {
+      const data = JSON.parse(e.data);
+      if (data.type === 'response') {
+        const messages = document.getElementById('chat-messages');
+        const msg = document.createElement('div');
+        msg.className = 'msg assistant';
+        msg.textContent = data.content;
+        messages.appendChild(msg);
+        messages.scrollTop = messages.scrollHeight;
+      }
+    } catch(err) {}
+  };
+  ws.onclose = () => setTimeout(connectWS, 3000);
+}
+connectWS();
+
+function sendChat() {
+  const input = document.getElementById('chat-input');
+  const text = input.value.trim();
+  if (!text) return;
+  const messages = document.getElementById('chat-messages');
+  const msg = document.createElement('div');
+  msg.className = 'msg user';
+  msg.textContent = text;
+  messages.appendChild(msg);
+  messages.scrollTop = messages.scrollHeight;
+  input.value = '';
+  if (ws && ws.readyState === 1) {
+    ws.send(JSON.stringify({type:'message',content:text,channel:'webchat',userId:'dashboard'}));
+  } else {
+    fetch('/api/message',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({content:text})})
+      .then(r=>r.json())
+      .then(data=>{const m=document.createElement('div');m.className='msg assistant';m.textContent=data.content||'No response';messages.appendChild(m);messages.scrollTop=messages.scrollHeight});
+  }
+}
+
+async function spawnAgent() {
+  const name = document.getElementById('agent-name').value.trim();
+  const model = document.getElementById('agent-model').value.trim();
+  if (!name) return alert('Agent name required');
+  const r = await fetch('/api/agents/spawn',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({name,model:model||undefined})});
+  const data = await r.json();
+  if (data.error) alert(data.error);
+  else { document.getElementById('agent-name').value=''; document.getElementById('agent-model').value=''; fetchData(); }
+}
+
+async function stopAgent(id) {
+  await fetch('/api/agents/stop',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({agentId:id})});
+  fetchData();
+}
+
+async function fetchData() {
+  try {
+    const [stats, sessions, skills, channels, security, agents] = await Promise.all([
+      fetch('/api/stats').then(r=>r.json()).catch(()=>({})),
+      fetch('/api/sessions').then(r=>r.json()).catch(()=>[]),
+      fetch('/api/skills').then(r=>r.json()).catch(()=>[]),
+      fetch('/api/channels').then(r=>r.json()).catch(()=>{}),
+      fetch('/api/security').then(r=>r.json()).catch(()=>({})),
+      fetch('/api/agents').then(r=>r.json()).catch(()=>({agents:[],capacity:{current:0,max:5}})),
+    ]);
+
+    // Stats
+    document.getElementById('s-agents').textContent = agents.capacity?.current || 0;
+    document.getElementById('s-sessions').textContent = Array.isArray(sessions) ? sessions.length : 0;
+    document.getElementById('s-tools').textContent = Array.isArray(skills) ? skills.length : 0;
+    document.getElementById('s-knowledge').textContent = stats.knowledge || 0;
+    document.getElementById('agent-count').textContent = (agents.capacity?.current||0) + ' agents';
+
+    // Health
+    const upSec = stats.uptime || 0;
+    const upStr = upSec > 3600 ? Math.floor(upSec/3600)+'h '+Math.floor((upSec%3600)/60)+'m' : Math.floor(upSec/60)+'m '+Math.floor(upSec%60)+'s';
+    document.getElementById('uptime').textContent = 'Up ' + upStr;
+    document.getElementById('health-info').innerHTML =
+      '<div style="display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-top:8px">'+
+      '<div><span style="color:var(--text-dim)">Uptime</span><br><strong>'+upStr+'</strong></div>'+
+      '<div><span style="color:var(--text-dim)">Memory</span><br><strong>'+(stats.memoryMB||'\u2014')+' MB</strong></div>'+
+      '<div><span style="color:var(--text-dim)">Version</span><br><strong>'+(stats.version||'\u2014')+'</strong></div></div>';
+
+    // Agents
+    if (agents.agents && agents.agents.length > 0) {
+      document.getElementById('agents-list').innerHTML =
+        '<table><tr><th>Name</th><th>ID</th><th>Model</th><th>Messages</th><th>Status</th><th>Action</th></tr>' +
+        agents.agents.map(a=>'<tr><td><strong>'+a.name+'</strong></td><td style="font-family:JetBrains Mono;font-size:12px;color:var(--text-dim)">'+a.id+'</td><td>'+a.model+'</td><td>'+a.messageCount+'</td><td><span class="badge '+(a.status==='running'?'active':'idle')+'">'+a.status+'</span></td><td><button class="btn danger" onclick="stopAgent(\\''+a.id+'\\')">Stop</button></td></tr>').join('')+'</table>';
+    }
+
+    // Sessions
+    if (Array.isArray(sessions) && sessions.length > 0) {
+      document.getElementById('sessions-list').innerHTML =
+        '<table><tr><th>ID</th><th>Channel</th><th>Messages</th><th>Last Active</th></tr>' +
+        sessions.map(s=>'<tr><td style="font-family:JetBrains Mono;font-size:12px">'+s.id.slice(0,8)+'</td><td>'+s.channel+'</td><td>'+(s.messageCount||0)+'</td><td>'+(s.lastActive||'\u2014')+'</td></tr>').join('')+'</table>';
+    } else {
+      document.getElementById('sessions-list').innerHTML = '<div class="empty-state"><p>No active sessions</p></div>';
+    }
+
+    // Skills
+    if (Array.isArray(skills) && skills.length > 0) {
+      document.getElementById('skills-list').innerHTML =
+        '<table><tr><th>Skill</th><th>Version</th><th>Source</th><th>Status</th></tr>' +
+        skills.map(s=>'<tr><td><strong>'+s.name+'</strong></td><td>'+s.version+'</td><td><span class="badge info">'+s.source+'</span></td><td><span class="badge active">enabled</span></td></tr>').join('')+'</table>';
+    }
+
+    // Channels
+    if (channels && typeof channels === 'object') {
+      const entries = Object.entries(channels);
+      document.getElementById('channels-list').innerHTML =
+        '<table><tr><th>Channel</th><th>Status</th></tr>' +
+        entries.map(([name,info])=>'<tr><td><strong>'+name+'</strong></td><td><span class="badge '+((info as any).status==='connected'?'active':'idle')+'">'+(info as any).status+'</span></td></tr>').join('')+'</table>';
+    }
+
+    // Security
+    document.getElementById('security-audit').innerHTML = security ? '<pre style="font-family:JetBrains Mono;font-size:12px;color:var(--text-dim);white-space:pre-wrap">'+JSON.stringify(security,null,2)+'</pre>' : 'No audit data';
+
+  } catch(e) { console.error('Fetch error:', e); }
+}
+
+fetchData();
+setInterval(fetchData, 15000);
+</script>
+</body>
+</html>`;
+}
+
+// src/gateway/server.ts
+var COMPONENT30 = "Gateway";
+var channels = /* @__PURE__ */ new Map();
+var wsClients = /* @__PURE__ */ new Set();
+var webChatChannel = null;
+function broadcast(data) {
+  const json = JSON.stringify(data);
+  for (const client of wsClients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(json);
+    }
+  }
+}
+async function handleInboundMessage(msg) {
+  logger_default.info(COMPONENT30, `[${msg.channel}] ${msg.userName || msg.userId}: ${msg.content.slice(0, 100)}`);
+  broadcast({
+    type: "message",
+    direction: "inbound",
+    channel: msg.channel,
+    userId: msg.userId,
+    userName: msg.userName,
+    content: msg.content,
+    timestamp: msg.timestamp.toISOString()
+  });
+  try {
+    const response = await routeMessage(msg.content, msg.channel, msg.userId);
+    const channel = channels.get(msg.channel);
+    if (channel) {
+      await channel.send({
+        channel: msg.channel,
+        userId: msg.userId,
+        groupId: msg.groupId,
+        content: response.content,
+        replyTo: msg.id
+      });
+    }
+    broadcast({
+      type: "message",
+      direction: "outbound",
+      channel: msg.channel,
+      userId: msg.userId,
+      content: response.content,
+      toolsUsed: response.toolsUsed,
+      tokenUsage: response.tokenUsage,
+      durationMs: response.durationMs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    logger_default.error(COMPONENT30, `Error processing message: ${error.message}`);
+    broadcast({ type: "error", message: error.message });
+  }
+}
+async function startGateway(options) {
+  const config = loadConfig();
+  const port = options?.port || config.gateway.port;
+  const host = options?.host || config.gateway.host;
+  logger_default.info(COMPONENT30, `Starting ${TITAN_NAME} Gateway v${TITAN_VERSION}`);
+  initMemory();
+  await initBuiltinSkills();
+  initAgents();
+  const app = express();
+  app.use(express.json());
+  app.get("/", (_req, res) => {
+    res.setHeader("Content-Type", "text/html");
+    res.send(getMissionControlHTML());
+  });
+  app.get("/api/stats", (_req, res) => {
+    const stats = getUsageStats();
+    res.json(stats);
+  });
+  app.get("/api/sessions", (_req, res) => {
+    const sessions = listSessions();
+    res.json(sessions);
+  });
+  app.get("/api/skills", (_req, res) => {
+    const skills = getSkills();
+    res.json(skills);
+  });
+  app.get("/api/tools", (_req, res) => {
+    const tools = getRegisteredTools().map((t) => ({
+      name: t.name,
+      description: t.description
+    }));
+    res.json(tools);
+  });
+  app.get("/api/channels", (_req, res) => {
+    const statuses = Array.from(channels.values()).map((ch) => ch.getStatus());
+    res.json(statuses);
+  });
+  app.get("/api/security", (_req, res) => {
+    const audit = auditSecurity();
+    res.json(audit);
+  });
+  app.get("/api/providers", async (_req, res) => {
+    const health = await healthCheckAll();
+    res.json(health);
+  });
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", version: TITAN_VERSION, uptime: process.uptime() });
+  });
+  app.get("/api/agents", (_req, res) => {
+    res.json({ agents: listAgents(), capacity: getAgentCapacity() });
+  });
+  app.post("/api/agents/spawn", (req, res) => {
+    const { name, model, systemPrompt } = req.body;
+    if (!name) {
+      res.status(400).json({ error: "name is required" });
+      return;
+    }
+    const result = spawnAgent({ name, model, systemPrompt });
+    res.json(result);
+  });
+  app.post("/api/agents/stop", (req, res) => {
+    const { agentId } = req.body;
+    if (!agentId) {
+      res.status(400).json({ error: "agentId is required" });
+      return;
+    }
+    const result = stopAgent(agentId);
+    res.json(result);
+  });
+  app.post("/api/message", async (req, res) => {
+    const { content, channel = "api", userId = "api-user" } = req.body;
+    if (!content) {
+      res.status(400).json({ error: "content is required" });
+      return;
+    }
+    try {
+      const response = await routeMessage(content, channel, userId);
+      res.json(response);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  const server = createServer(app);
+  const wss = new WebSocketServer({ server });
+  wss.on("connection", (ws) => {
+    wsClients.add(ws);
+    logger_default.info(COMPONENT30, `WebSocket client connected (${wsClients.size} total)`);
+    ws.on("message", async (rawData) => {
+      try {
+        const data = JSON.parse(rawData.toString());
+        if (data.type === "chat" && data.content) {
+          if (webChatChannel) {
+            webChatChannel.handleWebSocketMessage(data.userId || "webchat-user", data.content);
+          }
+        }
+      } catch (error) {
+        logger_default.error(COMPONENT30, `WebSocket error: ${error.message}`);
+      }
+    });
+    ws.on("close", () => {
+      wsClients.delete(ws);
+      logger_default.debug(COMPONENT30, `WebSocket client disconnected (${wsClients.size} total)`);
+    });
+  });
+  webChatChannel = new WebChatChannel();
+  channels.set("webchat", webChatChannel);
+  await webChatChannel.connect();
+  webChatChannel.on("message", handleInboundMessage);
+  const channelAdapters = [
+    ["discord", new DiscordChannel()],
+    ["telegram", new TelegramChannel()],
+    ["slack", new SlackChannel()],
+    ["googlechat", new GoogleChatChannel()]
+  ];
+  for (const [name, adapter] of channelAdapters) {
+    channels.set(name, adapter);
+    adapter.on("message", handleInboundMessage);
+    try {
+      await adapter.connect();
+    } catch (error) {
+      logger_default.debug(COMPONENT30, `Channel ${name} not available: ${error.message}`);
+    }
+  }
+  server.listen(port, host, () => {
+    logger_default.info(COMPONENT30, `Gateway listening on http://${host}:${port}`);
+    logger_default.info(COMPONENT30, `Dashboard: http://${host}:${port}`);
+    logger_default.info(COMPONENT30, `WebSocket: ws://${host}:${port}`);
+    logger_default.info(COMPONENT30, `API: http://${host}:${port}/api/health`);
+    logger_default.info(COMPONENT30, `
+Channels: ${Array.from(channels.values()).map((c) => `${c.displayName} (${c.getStatus().connected ? "\u2705" : "\u274C"})`).join(", ")}`);
+    logger_default.info(COMPONENT30, `Skills: ${getSkills().length} loaded`);
+    logger_default.info(COMPONENT30, `Tools: ${getRegisteredTools().length} registered`);
+  });
+}
+export {
+  startGateway
+};
+//# sourceMappingURL=server.js.map