@vizzor/cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -50,6 +50,26 @@ var init_schema = __esm({
         type: z.enum(["sqlite", "postgres"]).default("sqlite"),
         url: z.string().optional()
       }).default(() => ({ type: "sqlite" })),
+      ml: z.object({
+        enabled: z.boolean().default(false),
+        sidecarUrl: z.string().default("http://localhost:8000"),
+        fallbackToRules: z.boolean().default(true)
+      }).default(() => ({
+        enabled: false,
+        sidecarUrl: "http://localhost:8000",
+        fallbackToRules: true
+      })),
+      api: z.object({
+        port: z.number().default(3e3),
+        host: z.string().default("0.0.0.0"),
+        enableAuth: z.boolean().default(false),
+        corsOrigin: z.string().default("*")
+      }).default(() => ({
+        port: 3e3,
+        host: "0.0.0.0",
+        enableAuth: false,
+        corsOrigin: "*"
+      })),
       discordToken: z.string().optional(),
       discordGuildId: z.string().optional(),
       telegramToken: z.string().optional()
@@ -647,12 +667,12 @@ var init_adapter = __esm({
           toBlock: options?.toBlock,
           args: options?.args
         });
-        return logs.map((log2) => ({
-          eventName: log2.eventName ?? eventName,
-          blockNumber: log2.blockNumber ?? 0n,
-          transactionHash: log2.transactionHash ?? "0x",
-          args: log2.args ?? {},
-          logIndex: log2.logIndex ?? 0
+        return logs.map((log4) => ({
+          eventName: log4.eventName ?? eventName,
+          blockNumber: log4.blockNumber ?? 0n,
+          transactionHash: log4.transactionHash ?? "0x",
+          args: log4.args ?? {},
+          logIndex: log4.logIndex ?? 0
         }));
       }
       // ── Tokens ──────────────────────────────────────────────────────────────
@@ -1714,6 +1734,111 @@ var init_fear_greed = __esm({
   }
 });
 
+// src/utils/logger.ts
+import pino from "pino";
+function createLogger(name) {
+  const isDev = process.env["NODE_ENV"] !== "production";
+  if (isDev) {
+    return pino({
+      name,
+      level,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true
+        }
+      }
+    });
+  }
+  return pino({ name, level });
+}
+var level;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    level = process.env["VIZZOR_LOG_LEVEL"] ?? "info";
+  }
+});
+
+// src/ml/client.ts
+function getMLClient() {
+  return mlClient;
+}
+var log, mlClient;
+var init_client = __esm({
+  "src/ml/client.ts"() {
+    "use strict";
+    init_logger();
+    log = createLogger("ml-client");
+    mlClient = null;
+  }
+});
+
+// src/ml/feature-engineer.ts
+async function buildFeatureVector(symbol) {
+  const [ta, fundingResult, tickerResult, fgResult, klines] = await Promise.allSettled([
+    analyzeTechnicals(symbol, "4h"),
+    fetchFundingRate(symbol),
+    fetchTickerPrice(symbol),
+    fetchFearGreedIndex(1),
+    fetchKlines(symbol, "4h", 100)
+  ]);
+  const indicators = ta.status === "fulfilled" ? ta.value.indicators : null;
+  const funding = fundingResult.status === "fulfilled" ? fundingResult.value : null;
+  const ticker = tickerResult.status === "fulfilled" ? tickerResult.value : null;
+  const fg = fgResult.status === "fulfilled" ? fgResult.value : null;
+  const candles = klines.status === "fulfilled" ? klines.value : [];
+  let rsiSlope = 0;
+  if (candles.length >= 17) {
+    const closes = candles.map((k) => k.close);
+    const recentRsi = calculateRSI(closes, 14);
+    const olderCloses = closes.slice(0, -3);
+    const olderRsi = calculateRSI(olderCloses, 14);
+    if (recentRsi !== null && olderRsi !== null) {
+      rsiSlope = recentRsi - olderRsi;
+    }
+  }
+  let volumeRatio = 1;
+  if (candles.length >= 21) {
+    const currentVolume = candles[candles.length - 1].volume;
+    const avgVolume = candles.slice(-21, -1).reduce((sum, k) => sum + k.volume, 0) / 20;
+    volumeRatio = avgVolume > 0 ? currentVolume / avgVolume : 1;
+  }
+  const price = ticker?.price ?? candles[candles.length - 1]?.close ?? 0;
+  const ema12 = indicators?.ema12 ?? 0;
+  const ema26 = indicators?.ema26 ?? 0;
+  const emaCrossoverPct = price > 0 ? (ema12 - ema26) / price * 100 : 0;
+  const atr = indicators?.atr ?? 0;
+  const atrPct = price > 0 ? atr / price * 100 : 0;
+  return {
+    rsi: indicators?.rsi ?? 50,
+    macdHistogram: indicators?.macd?.histogram ?? 0,
+    bollingerPercentB: indicators?.bollingerBands?.percentB ?? 0.5,
+    ema12,
+    ema26,
+    atr,
+    obv: indicators?.obv ?? 0,
+    fundingRate: funding?.fundingRate ?? 0,
+    fearGreed: fg?.current.value ?? 50,
+    priceChange24h: ticker?.change24h ?? 0,
+    rsiSlope,
+    volumeRatio,
+    emaCrossoverPct,
+    atrPct,
+    symbol: symbol.toUpperCase(),
+    timestamp: Date.now()
+  };
+}
+var init_feature_engineer = __esm({
+  "src/ml/feature-engineer.ts"() {
+    "use strict";
+    init_technical_analysis();
+    init_binance();
+    init_fear_greed();
+    init_indicators();
+  }
+});
+
 // src/core/trends/predictor.ts
 async function generatePrediction(symbol) {
   const reasoning = [];
@@ -1834,7 +1959,7 @@ async function generatePrediction(symbol) {
   const negativeCount = signalValues.filter((v) => v < 0).length;
   const agreement = Math.max(positiveCount, negativeCount) / Math.max(1, positiveCount + negativeCount);
   const confidence = Math.round(Math.min(95, completeness / 5 * agreement * 100));
-  return {
+  const rulePrediction = {
     symbol: symbol.toUpperCase(),
     direction,
     confidence,
@@ -1844,6 +1969,34 @@ async function generatePrediction(symbol) {
     composite: Math.round(composite),
     disclaimer: "This is not financial advice. Predictions are based on historical data and AI analysis. Always do your own research."
   };
+  const mlClient2 = getMLClient();
+  if (mlClient2) {
+    try {
+      const features = await buildFeatureVector(symbol);
+      const mlPred = await mlClient2.predict(features);
+      if (mlPred) {
+        return mergePredictions(rulePrediction, mlPred);
+      }
+    } catch {
+    }
+  }
+  return rulePrediction;
+}
+function mergePredictions(rule, ml) {
+  const mlComposite = ml.direction === "up" ? ml.probability * 100 : ml.direction === "down" ? -(ml.probability * 100) : 0;
+  const mergedComposite = Math.round(rule.composite * 0.4 + mlComposite * 0.6);
+  const mergedDirection = mergedComposite > 15 ? "up" : mergedComposite < -15 ? "down" : "sideways";
+  const mergedConfidence = Math.round(Math.min(95, rule.confidence * 0.4 + ml.confidence * 0.6));
+  return {
+    ...rule,
+    direction: mergedDirection,
+    confidence: mergedConfidence,
+    composite: mergedComposite,
+    reasoning: [
+      ...rule.reasoning,
+      `ML (${ml.model}): ${ml.direction} with ${(ml.probability * 100).toFixed(1)}% probability (horizon: ${ml.horizon})`
+    ]
+  };
 }
 var WEIGHTS2;
 var init_predictor = __esm({
@@ -1853,6 +2006,8 @@ var init_predictor = __esm({
     init_sentiment();
     init_fear_greed();
     init_binance();
+    init_client();
+    init_feature_engineer();
     WEIGHTS2 = {
       technical: 40,
       sentiment: 20,
@@ -5233,7 +5388,7 @@ async function analyze(systemPrompt, userMessage, tools) {
   return p.analyze(systemPrompt, userMessage, tools, toolHandler);
 }
 var provider, config, toolHandler;
-var init_client = __esm({
+var init_client2 = __esm({
   "src/ai/client.ts"() {
     "use strict";
     init_registry2();
@@ -5557,32 +5712,6 @@ var init_cache = __esm({
   }
 });
 
-// src/utils/logger.ts
-import pino from "pino";
-function createLogger(name) {
-  const isDev = process.env["NODE_ENV"] !== "production";
-  if (isDev) {
-    return pino({
-      name,
-      level,
-      transport: {
-        target: "pino-pretty",
-        options: {
-          colorize: true
-        }
-      }
-    });
-  }
-  return pino({ name, level });
-}
-var level;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    level = process.env["VIZZOR_LOG_LEVEL"] ?? "info";
-  }
-});
-
 // src/core/agent/engine.ts
 var logger, AgentEngine;
 var init_engine = __esm({
@@ -6053,545 +6182,1041 @@ var init_agent = __esm({
   }
 });
 
-// src/ai/tool-handler.ts
-async function handleTool(name, input) {
-  const params = input;
-  switch (name) {
-    case "get_token_info": {
-      const address = String(params["address"] ?? "");
-      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
-      const adapter = getAdapter(chain);
-      await adapter.connect(void 0, getConfig().etherscanApiKey);
-      const info = await adapter.getTokenInfo(address);
-      return {
-        address: info.address,
-        name: info.name,
-        symbol: info.symbol,
-        decimals: info.decimals,
-        totalSupply: info.totalSupply.toString()
-      };
-    }
-    case "analyze_wallet": {
-      const address = String(params["address"] ?? "");
-      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
-      const adapter = getAdapter(chain);
-      await adapter.connect(void 0, getConfig().etherscanApiKey);
-      const analysis = await analyzeWallet(address, adapter);
-      return {
-        address: analysis.address,
-        chain: analysis.chain,
-        balance: analysis.balance.toString(),
-        transactionCount: analysis.transactionCount,
-        riskLevel: analysis.riskLevel,
-        patterns: analysis.patterns
-      };
-    }
-    case "check_rug_indicators": {
-      const address = String(params["address"] ?? "");
-      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
-      const adapter = getAdapter(chain);
-      await adapter.connect(void 0, getConfig().etherscanApiKey);
-      const indicators = await detectRugIndicators(address, adapter);
-      return {
-        isHoneypot: indicators.isHoneypot,
-        hasLiquidityLock: indicators.hasLiquidityLock,
-        ownerCanMint: indicators.ownerCanMint,
-        ownerCanPause: indicators.ownerCanPause,
-        hasBlacklist: indicators.hasBlacklist,
-        highSellTax: indicators.highSellTax,
-        riskScore: indicators.riskScore,
-        details: indicators.details
-      };
-    }
-    case "get_market_data": {
-      const symbol = String(params["symbol"] ?? "");
-      try {
-        const binance = await fetchTickerPrice(symbol);
-        const gecko = await fetchMarketData(symbol).catch(() => null);
-        return {
-          symbol: binance.symbol,
-          name: gecko?.name ?? binance.symbol,
-          price: binance.price,
-          priceChange24h: binance.change24h,
-          priceChange7d: gecko?.priceChange7d ?? null,
-          volume24h: gecko?.volume24h ?? null,
-          marketCap: gecko?.marketCap ?? null,
-          rank: gecko?.rank ?? null,
-          source: "binance+coingecko"
-        };
-      } catch {
-        const data = await fetchMarketData(symbol);
-        if (!data) {
-          return { error: `No market data found for "${symbol}"` };
-        }
-        return data;
+// src/data/sqlite-store.ts
+function ensureAgentTables2() {
+  const db2 = getDb();
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      strategy TEXT NOT NULL,
+      pairs TEXT NOT NULL,
+      interval_seconds INTEGER NOT NULL DEFAULT 60,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS agent_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      action TEXT NOT NULL,
+      confidence INTEGER NOT NULL,
+      reasoning TEXT NOT NULL,
+      signals TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    )
+  `);
+}
+function rowToConfig(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    strategy: row.strategy,
+    pairs: JSON.parse(row.pairs),
+    interval: row.interval_seconds,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var SqliteStore;
+var init_sqlite_store = __esm({
+  "src/data/sqlite-store.ts"() {
+    "use strict";
+    init_cache();
+    SqliteStore = class {
+      // ---- Cache ---------------------------------------------------------------
+      async getCached(key) {
+        return getCached(key);
       }
-    }
-    case "search_upcoming_icos": {
-      const category = params["category"] ? String(params["category"]) : void 0;
-      const chain = params["chain"] ? String(params["chain"]) : void 0;
-      const roundType = params["roundType"] ? String(params["roundType"]) : void 0;
-      const projects = category || chain || roundType ? await searchICOs(void 0, category, chain, roundType) : await fetchUpcomingICOs();
-      return {
-        projects: projects.map((p) => ({
-          name: p.name,
-          category: p.category,
-          chain: p.chain,
-          roundType: p.roundType,
-          raisedAmount: p.raisedAmount,
-          valuation: p.valuation,
-          investors: p.investors.slice(0, 5),
-          startDate: p.startDate,
-          description: p.description,
-          website: p.website
-        }))
-      };
-    }
-    case "get_funding_history": {
-      const fundingName = String(params["name"] ?? "");
-      const type = String(params["type"] ?? "project");
-      if (type === "investor") {
-        const portfolio = await getInvestorPortfolio(fundingName);
-        return {
-          investor: fundingName,
-          investments: portfolio.map((p) => ({
-            name: p.name,
-            round: p.roundType,
-            amount: p.raisedAmount,
-            chain: p.chain,
-            category: p.category,
-            date: p.startDate
-          }))
-        };
+      async setCache(key, value, ttlSeconds) {
+        setCache(key, value, ttlSeconds);
       }
-      const history = await getProjectFundingHistory(fundingName);
-      return {
-        project: history.name,
-        rounds: history.rounds.map((r) => ({
-          round: r.roundType,
-          amount: r.raisedAmount,
-          valuation: r.valuation,
-          investors: r.investors.slice(0, 5),
-          date: r.startDate,
-          previousRounds: r.previousRounds
-        }))
-      };
-    }
-    case "search_token_dex": {
-      const query = String(params["query"] ?? "");
-      const pairs = await fetchTokenFromDex(query);
-      return {
-        results: pairs.slice(0, 5).map((p) => ({
-          name: p.baseToken.name,
-          symbol: p.baseToken.symbol,
-          chain: p.chainId,
-          dex: p.dexId,
-          priceUsd: p.priceUsd,
-          volume24h: p.volume?.h24 ?? 0,
-          liquidity: p.liquidity?.usd ?? 0,
-          priceChange24h: p.priceChange?.h24 ?? 0,
-          marketCap: p.marketCap ?? p.fdv ?? null,
-          buys24h: p.txns?.h24?.buys ?? 0,
-          sells24h: p.txns?.h24?.sells ?? 0,
-          pairAddress: p.pairAddress,
-          url: p.url
-        }))
-      };
-    }
-    case "get_trending": {
-      const trending = await fetchTrendingTokens();
-      return {
-        trending: trending.slice(0, 10).map((t) => ({
-          name: t.name,
-          symbol: t.symbol,
-          chain: t.chain,
-          priceUsd: t.priceUsd,
-          priceChange24h: t.priceChange24h,
-          volume24h: t.volume24h,
-          marketCap: t.marketCap,
-          source: t.source,
-          url: t.url
-        }))
-      };
-    }
-    case "get_crypto_news": {
-      const symbol = params["symbol"] ? String(params["symbol"]) : void 0;
-      const news = await fetchCryptoNews(symbol, getConfig().cryptopanicApiKey);
-      return {
-        news: news.slice(0, 10).map((n) => ({
-          title: n.title,
-          sentiment: n.sentiment,
-          source: n.source.title,
-          publishedAt: n.publishedAt,
-          url: n.url
-        }))
-      };
-    }
-    case "get_raises": {
-      const raises = await fetchRecentRaises(30);
-      let filtered = raises;
-      if (params["category"]) {
-        const cat = String(params["category"]).toLowerCase();
-        filtered = filtered.filter(
-          (r) => r.category?.toLowerCase().includes(cat) || r.sector?.toLowerCase().includes(cat)
+      // ---- Agents --------------------------------------------------------------
+      async createAgent(config2) {
+        ensureAgentTables2();
+        getDb().prepare(
+          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          config2.id,
+          config2.name,
+          config2.strategy,
+          JSON.stringify(config2.pairs),
+          config2.interval,
+          config2.createdAt,
+          config2.updatedAt
         );
+        return config2;
       }
-      if (params["chain"]) {
-        const ch = String(params["chain"]).toLowerCase();
-        filtered = filtered.filter((r) => r.chains.some((c) => c.toLowerCase().includes(ch)));
+      async listAgents() {
+        ensureAgentTables2();
+        const rows = getDb().prepare("SELECT * FROM agents ORDER BY created_at DESC").all();
+        return rows.map(rowToConfig);
       }
-      return {
-        raises: filtered.slice(0, 10).map((r) => ({
-          name: r.name,
-          round: r.round,
-          amount: r.amount,
-          chains: r.chains,
-          sector: r.sector,
-          category: r.category,
-          leadInvestors: r.leadInvestors,
-          date: new Date(r.date * 1e3).toISOString().split("T")[0]
-        }))
-      };
-    }
-    case "get_token_security": {
-      const address = String(params["address"] ?? "");
-      const chain = String(params["chain"] ?? "ethereum");
-      const security = await checkTokenSecurity(address, chain);
-      if (!security) {
-        return { error: `No security data for ${address} on ${chain}` };
+      async getAgentById(id) {
+        ensureAgentTables2();
+        const row = getDb().prepare("SELECT * FROM agents WHERE id = ?").get(id);
+        return row ? rowToConfig(row) : null;
       }
-      return {
-        contractAddress: security.contractAddress,
-        chain: security.chain,
-        riskLevel: security.riskLevel,
-        isHoneypot: security.isHoneypot,
-        isMintable: security.isMintable,
-        buyTax: security.buyTax,
-        sellTax: security.sellTax,
-        isOpenSource: security.isOpenSource,
-        isProxy: security.isProxy,
-        hiddenOwner: security.hiddenOwner,
-        cannotBuy: security.cannotBuy,
-        cannotSellAll: security.cannotSellAll,
-        isBlacklisted: security.isBlacklisted,
-        holderCount: security.holderCount,
-        lpHolderCount: security.lpHolderCount,
-        creatorPercent: security.creatorPercent,
-        ownerPercent: security.ownerPercent,
-        trustList: security.trustList
-      };
-    }
-    case "get_fear_greed": {
-      const data = await fetchFearGreedIndex(7);
-      return {
-        current: { value: data.current.value, classification: data.current.classification },
-        previous: data.previous ? { value: data.previous.value, classification: data.previous.classification } : null,
-        history: data.history.map((h) => ({
-          value: h.value,
-          classification: h.classification,
-          date: new Date(h.timestamp * 1e3).toISOString().split("T")[0]
-        }))
-      };
-    }
-    case "get_derivatives_data": {
-      const symbol = String(params["symbol"] ?? "BTC");
-      const [fundingResult, oiResult] = await Promise.allSettled([
-        fetchFundingRate(symbol),
-        fetchOpenInterest(symbol)
-      ]);
-      const result = { symbol: symbol.toUpperCase() };
-      if (fundingResult.status === "fulfilled") {
-        result["fundingRate"] = fundingResult.value.fundingRate;
-        result["fundingRatePct"] = `${(fundingResult.value.fundingRate * 100).toFixed(4)}%`;
-        result["markPrice"] = fundingResult.value.markPrice;
+      async getAgentByName(name) {
+        ensureAgentTables2();
+        const row = getDb().prepare("SELECT * FROM agents WHERE name = ?").get(name);
+        return row ? rowToConfig(row) : null;
       }
-      if (oiResult.status === "fulfilled") {
-        result["openInterest"] = oiResult.value.openInterest;
-        result["openInterestNotional"] = oiResult.value.notionalValue;
+      async deleteAgent(id) {
+        ensureAgentTables2();
+        const result = getDb().prepare("DELETE FROM agents WHERE id = ?").run(id);
+        getDb().prepare("DELETE FROM agent_decisions WHERE agent_id = ?").run(id);
+        return result.changes > 0;
       }
-      return result;
-    }
-    case "get_technical_analysis": {
-      const symbol = String(params["symbol"] ?? "BTC");
-      const timeframe = String(params["timeframe"] ?? "4h");
-      const ta = await analyzeTechnicals(symbol, timeframe);
-      return {
-        symbol: ta.symbol,
-        timeframe: ta.timeframe,
-        composite: ta.composite,
-        signals: ta.signals.map((s) => ({
-          name: s.name,
-          signal: s.signal,
-          strength: s.strength,
-          description: s.description
-        })),
-        indicators: {
-          rsi: ta.indicators.rsi ? Math.round(ta.indicators.rsi * 100) / 100 : null,
-          macd: ta.indicators.macd,
-          bollingerBands: ta.indicators.bollingerBands,
-          ema12: ta.indicators.ema12,
-          ema26: ta.indicators.ema26,
-          atr: ta.indicators.atr
-        }
-      };
-    }
-    case "get_prediction": {
-      const symbol = String(params["symbol"] ?? "BTC");
-      const prediction = await generatePrediction(symbol);
-      return {
-        symbol: prediction.symbol,
-        direction: prediction.direction,
-        confidence: prediction.confidence,
-        composite: prediction.composite,
-        timeframe: prediction.timeframe,
-        signals: prediction.signals,
-        reasoning: prediction.reasoning,
-        disclaimer: prediction.disclaimer
-      };
-    }
-    case "create_agent": {
-      const agentName = String(params["name"] ?? "");
-      const strategy = String(params["strategy"] ?? "momentum");
-      const pairsRaw = String(params["pairs"] ?? "BTC,ETH");
-      const interval = params["interval"] ? Number(params["interval"]) : 60;
-      const agentPairs = pairsRaw.split(",").map((p) => p.trim().toUpperCase());
-      const agent = createAgent(agentName, strategy, agentPairs, interval);
-      return {
-        id: agent.id,
-        name: agent.name,
-        strategy: agent.strategy,
-        pairs: agent.pairs,
-        interval: agent.interval,
-        message: `Agent "${agent.name}" created. Use /agent start ${agent.name} to activate.`
-      };
-    }
-    case "list_agents": {
-      const agents = listAgents();
-      return {
-        agents: agents.map((a) => {
-          const status = getAgentStatus(a.id);
-          return {
-            name: a.name,
-            strategy: a.strategy,
-            pairs: a.pairs,
-            interval: a.interval,
-            status: status?.status ?? "idle",
-            cycleCount: status?.cycleCount ?? 0
-          };
-        })
-      };
-    }
-    case "get_agent_status": {
-      const agentName = String(params["name"] ?? "");
-      const agent = getAgentByName(agentName);
-      if (!agent) return { error: `Agent "${agentName}" not found` };
-      const state = getAgentStatus(agent.id);
-      if (!state) return { error: `Agent "${agentName}" not found` };
-      const decisions = getRecentDecisions(agent.id, 5);
-      return {
-        name: state.config.name,
-        status: state.status,
-        strategy: state.config.strategy,
-        pairs: state.config.pairs,
-        cycleCount: state.cycleCount,
-        error: state.error,
-        recentDecisions: decisions.map((d) => ({
-          symbol: d.symbol,
-          action: d.decision.action,
-          confidence: d.decision.confidence,
-          reasoning: d.decision.reasoning,
-          timestamp: new Date(d.timestamp).toISOString()
-        }))
-      };
-    }
-    default:
-      return { error: `Unknown tool: ${name}` };
-  }
-}
-var init_tool_handler = __esm({
-  "src/ai/tool-handler.ts"() {
-    "use strict";
-    init_registry();
-    init_loader();
-    init_constants();
-    init_wallet_analyzer();
-    init_rug_detector();
-    init_market();
-    init_ico_tracker();
-    init_cryptopanic();
-    init_defillama();
-    init_binance();
-    init_goplus();
-    init_fear_greed();
-    init_technical_analysis();
-    init_predictor();
-    init_agent();
+      async logDecision(result) {
+        ensureAgentTables2();
+        getDb().prepare(
+          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          result.agentId,
+          result.symbol,
+          result.decision.action,
+          result.decision.confidence,
+          JSON.stringify(result.decision.reasoning),
+          JSON.stringify(result.signals),
+          result.timestamp
+        );
+      }
+      async getDecisions(agentId, limit) {
+        ensureAgentTables2();
+        const rows = getDb().prepare("SELECT * FROM agent_decisions WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?").all(agentId, limit);
+        return rows.map((r) => ({
+          agentId: r.agent_id,
+          symbol: r.symbol,
+          timestamp: r.created_at,
+          signals: JSON.parse(r.signals),
+          decision: {
+            action: r.action,
+            confidence: r.confidence,
+            reasoning: JSON.parse(r.reasoning)
+          }
+        }));
+      }
+      // ---- Time-series (no-op for SQLite) --------------------------------------
+      async insertOHLCV(_records) {
+      }
+      async queryOHLCV(_symbol, _timeframe, _from, _to) {
+        return [];
+      }
+      // ---- Predictions (no-op for SQLite) --------------------------------------
+      async logPrediction(_prediction) {
+      }
+      async getPredictionAccuracy(_model, _days) {
+        return {
+          model: _model,
+          totalPredictions: 0,
+          correctPredictions: 0,
+          accuracy: 0,
+          byDirection: {
+            up: { total: 0, correct: 0, accuracy: 0 },
+            down: { total: 0, correct: 0, accuracy: 0 },
+            sideways: { total: 0, correct: 0, accuracy: 0 }
+          },
+          period: `${_days}d`
+        };
+      }
+      // ---- Lifecycle -----------------------------------------------------------
+      async close() {
+      }
+    };
   }
 });
 
-// src/ai/tools.ts
-var VIZZOR_TOOLS;
-var init_tools = __esm({
-  "src/ai/tools.ts"() {
+// src/data/postgres-store.ts
+var postgres_store_exports = {};
+__export(postgres_store_exports, {
+  PostgresStore: () => PostgresStore
+});
+import pg from "pg";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename, __dirname, PostgresStore;
+var init_postgres_store = __esm({
+  "src/data/postgres-store.ts"() {
     "use strict";
-    VIZZOR_TOOLS = [
-      {
-        name: "get_token_info",
-        description: "Get on-chain token information including name, symbol, decimals, total supply, and top holders for a given contract address and chain.",
-        input_schema: {
-          type: "object",
-          properties: {
-            address: {
-              type: "string",
-              description: "The token contract address (e.g. 0x...)."
-            },
-            chain: {
-              type: "string",
-              description: 'The blockchain to query (e.g. "ethereum", "bsc", "polygon", "arbitrum").'
-            }
-          },
-          required: ["address", "chain"]
-        }
-      },
-      {
-        name: "analyze_wallet",
-        description: "Analyze a wallet address for transaction patterns, token holdings, DeFi interactions, and behavioral signals such as accumulation or distribution phases.",
-        input_schema: {
-          type: "object",
-          properties: {
-            address: {
-              type: "string",
-              description: "The wallet address to analyze."
-            },
-            chain: {
-              type: "string",
-              description: 'The blockchain the wallet resides on (e.g. "ethereum", "bsc").'
-            },
-            depth: {
-              type: "number",
-              description: "How many recent transactions to inspect. Defaults to 100."
-            }
-          },
-          required: ["address", "chain"]
-        }
-      },
-      {
-        name: "check_rug_indicators",
-        description: "Check a token for common rug pull indicators including honeypot detection, liquidity locks, ownership status, hidden mints, and holder concentration.",
-        input_schema: {
-          type: "object",
-          properties: {
-            address: {
-              type: "string",
-              description: "The token contract address to check."
-            },
-            chain: {
-              type: "string",
-              description: "The blockchain the token is deployed on."
-            }
-          },
-          required: ["address", "chain"]
-        }
-      },
-      {
-        name: "get_market_data",
-        description: "Get LIVE current market data for a token including price, 24h volume, market cap, price change percentages, and circulating supply. Returns real-time data \u2014 never quote prices from training data.",
-        input_schema: {
-          type: "object",
-          properties: {
-            symbol: {
-              type: "string",
-              description: 'The token ticker symbol (e.g. "ETH", "BTC", "UNI").'
-            },
-            currency: {
-              type: "string",
-              description: 'The fiat currency for price quotes. Defaults to "usd".'
-            }
-          },
-          required: ["symbol"]
-        }
-      },
-      {
-        name: "search_upcoming_icos",
-        description: "Search for CURRENT upcoming ICOs, token launches, and fundraising rounds filtered by category, blockchain, or round type. Returns LIVE data from DeFiLlama raises and Pump.fun launches, updated daily. MUST call for any ICO/launch question \u2014 training data is stale.",
-        input_schema: {
-          type: "object",
-          properties: {
-            category: {
-              type: "string",
-              description: 'Filter by project category (e.g. "defi", "gaming", "infrastructure", "nft", "ai").'
-            },
-            chain: {
-              type: "string",
-              description: 'Filter by blockchain (e.g. "ethereum", "solana", "bsc").'
-            },
-            roundType: {
-              type: "string",
-              description: 'Filter by funding round type (e.g. "Seed", "Pre-Seed", "Series A", "Series B", "Token Launch").'
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of results to return. Defaults to 10."
-            }
-          },
-          required: []
-        }
-      },
-      {
-        name: "get_funding_history",
-        description: "Get complete funding history for a project by name. Returns all known fundraising rounds with amounts, investors, valuations, and dates. Also works for looking up an investor portfolio.",
-        input_schema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Project name or investor name to look up."
-            },
-            type: {
-              type: "string",
-              description: 'Type of lookup: "project" for project funding history, "investor" for investor portfolio. Defaults to "project".'
-            }
-          },
-          required: ["name"]
-        }
-      },
-      {
-        name: "search_token_dex",
-        description: "Search for any token on decentralized exchanges via DexScreener. Returns real-time price, volume, liquidity, buy/sell counts, pair info. Works for all tokens including meme coins and newly launched tokens.",
-        input_schema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "Token name, symbol, or contract address to search for."
-            }
-          },
-          required: ["query"]
-        }
-      },
-      {
-        name: "get_trending",
-        description: "Get REAL-TIME trending and hot tokens from DexScreener (boosted tokens) and CoinGecko trending combined. Returns what the market is excited about RIGHT NOW \u2014 trends change hourly. Always call for trending/hot token questions.",
-        input_schema: {
-          type: "object",
-          properties: {},
-          required: []
-        }
-      },
-      {
-        name: "get_crypto_news",
-        description: "Get LIVE latest crypto news with sentiment analysis for a specific token or the market in general. Returns current headlines from CryptoPanic \u2014 MUST call for news questions, training data is outdated.",
-        input_schema: {
-          type: "object",
-          properties: {
-            symbol: {
-              type: "string",
-              description: 'Token symbol to filter news for (e.g. "BTC", "ETH", "SOL"). Omit for general crypto news.'
-            }
-          },
-          required: []
-        }
-      },
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    PostgresStore = class {
+      pool;
+      initialized = false;
+      constructor(connectionUrl) {
+        this.pool = new pg.Pool({ connectionString: connectionUrl, max: 10 });
+      }
+      async init() {
+        if (this.initialized) return;
+        const migrationPath = resolve2(__dirname, "migrations", "001-init.sql");
+        const sql = readFileSync2(migrationPath, "utf-8");
+        await this.pool.query(sql);
+        this.initialized = true;
+      }
+      async query(text, params) {
+        await this.init();
+        return this.pool.query(text, params);
+      }
+      // ---- Cache ---------------------------------------------------------------
+      async getCached(key) {
+        const now = Math.floor(Date.now() / 1e3);
+        const { rows } = await this.query(
+          "SELECT value FROM cache WHERE key = $1 AND expires_at > $2",
+          [key, now]
+        );
+        if (rows.length === 0) return null;
+        return rows[0].value;
+      }
+      async setCache(key, value, ttlSeconds) {
+        const now = Math.floor(Date.now() / 1e3);
+        const expiresAt = now + ttlSeconds;
+        await this.query(
+          `INSERT INTO cache (key, value, expires_at, created_at)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (key) DO UPDATE SET value = $2, expires_at = $3`,
+          [key, JSON.stringify(value), expiresAt, now]
+        );
+      }
+      // ---- Agents --------------------------------------------------------------
+      async createAgent(config2) {
+        await this.query(
+          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            config2.id,
+            config2.name,
+            config2.strategy,
+            JSON.stringify(config2.pairs),
+            config2.interval,
+            config2.createdAt,
+            config2.updatedAt
+          ]
+        );
+        return config2;
+      }
+      async listAgents() {
+        const { rows } = await this.query("SELECT * FROM agents ORDER BY created_at DESC");
+        return rows.map((r) => ({
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        }));
+      }
+      async getAgentById(id) {
+        const { rows } = await this.query("SELECT * FROM agents WHERE id = $1", [id]);
+        if (rows.length === 0) return null;
+        const r = rows[0];
+        return {
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        };
+      }
+      async getAgentByName(name) {
+        const { rows } = await this.query("SELECT * FROM agents WHERE name = $1", [name]);
+        if (rows.length === 0) return null;
+        const r = rows[0];
+        return {
+          id: r.id,
+          name: r.name,
+          strategy: r.strategy,
+          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
+          interval: r.interval_seconds,
+          createdAt: Number(r.created_at),
+          updatedAt: Number(r.updated_at)
+        };
+      }
+      async deleteAgent(id) {
+        const result = await this.query("DELETE FROM agents WHERE id = $1", [id]);
+        return (result.rowCount ?? 0) > 0;
+      }
+      async logDecision(result) {
+        await this.query(
+          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            result.agentId,
+            result.symbol,
+            result.decision.action,
+            result.decision.confidence,
+            JSON.stringify(result.decision.reasoning),
+            JSON.stringify(result.signals),
+            result.timestamp
+          ]
+        );
+      }
+      async getDecisions(agentId, limit) {
+        const { rows } = await this.query("SELECT * FROM agent_decisions WHERE agent_id = $1 ORDER BY created_at DESC LIMIT $2", [
+          agentId,
+          limit
+        ]);
+        return rows.map((r) => ({
+          agentId: r.agent_id,
+          symbol: r.symbol,
+          timestamp: Number(r.created_at),
+          signals: typeof r.signals === "string" ? JSON.parse(r.signals) : r.signals,
+          decision: {
+            action: r.action,
+            confidence: r.confidence,
+            reasoning: typeof r.reasoning === "string" ? JSON.parse(r.reasoning) : r.reasoning
+          }
+        }));
+      }
+      // ---- Time-series ---------------------------------------------------------
+      async insertOHLCV(records) {
+        if (records.length === 0) return;
+        const values = [];
+        const placeholders = [];
+        for (let i = 0; i < records.length; i++) {
+          const r = records[i];
+          const offset = i * 9;
+          placeholders.push(
+            `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`
+          );
+          values.push(
+            new Date(r.time).toISOString(),
+            r.symbol,
+            r.timeframe,
+            r.open,
+            r.high,
+            r.low,
+            r.close,
+            r.volume,
+            r.trades
+          );
+        }
+        await this.query(
+          `INSERT INTO ohlcv (time, symbol, timeframe, open, high, low, close, volume, trades)
+       VALUES ${placeholders.join(", ")}
+       ON CONFLICT (symbol, timeframe, time) DO UPDATE
+       SET open = EXCLUDED.open, high = EXCLUDED.high, low = EXCLUDED.low,
+           close = EXCLUDED.close, volume = EXCLUDED.volume, trades = EXCLUDED.trades`,
+          values
+        );
+      }
+      async queryOHLCV(symbol, timeframe, from, to) {
+        const { rows } = await this.query(
+          `SELECT * FROM ohlcv
+       WHERE symbol = $1 AND timeframe = $2 AND time >= $3 AND time <= $4
+       ORDER BY time ASC`,
+          [symbol, timeframe, new Date(from).toISOString(), new Date(to).toISOString()]
+        );
+        return rows.map((r) => ({
+          time: new Date(r.time).getTime(),
+          symbol: r.symbol,
+          timeframe: r.timeframe,
+          open: r.open,
+          high: r.high,
+          low: r.low,
+          close: r.close,
+          volume: r.volume,
+          trades: r.trades
+        }));
+      }
+      // ---- Predictions ---------------------------------------------------------
+      async logPrediction(prediction) {
+        await this.query(
+          `INSERT INTO predictions (symbol, model, direction, probability, horizon, features, predicted_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+          [
+            prediction.symbol,
+            prediction.model,
+            prediction.direction,
+            prediction.probability,
+            prediction.horizon,
+            JSON.stringify(prediction.features),
+            new Date(prediction.predictedAt).toISOString()
+          ]
+        );
+      }
+      async getPredictionAccuracy(model, days) {
+        const since = new Date(Date.now() - days * 864e5).toISOString();
+        const { rows: totals } = await this.query(
+          `SELECT direction,
+              COUNT(*)::text AS total,
+              COUNT(*) FILTER (WHERE was_correct = true)::text AS correct
+       FROM predictions
+       WHERE model = $1 AND predicted_at >= $2 AND was_correct IS NOT NULL
+       GROUP BY direction`,
+          [model, since]
+        );
+        const byDir = {
+          up: { total: 0, correct: 0, accuracy: 0 },
+          down: { total: 0, correct: 0, accuracy: 0 },
+          sideways: { total: 0, correct: 0, accuracy: 0 }
+        };
+        let totalAll = 0;
+        let correctAll = 0;
+        for (const row of totals) {
+          const t = parseInt(row.total, 10);
+          const c = parseInt(row.correct, 10);
+          totalAll += t;
+          correctAll += c;
+          const dir = row.direction;
+          if (byDir[dir]) {
+            byDir[dir] = { total: t, correct: c, accuracy: t > 0 ? c / t : 0 };
+          }
+        }
+        return {
+          model,
+          totalPredictions: totalAll,
+          correctPredictions: correctAll,
+          accuracy: totalAll > 0 ? correctAll / totalAll : 0,
+          byDirection: byDir,
+          period: `${days}d`
+        };
+      }
+      // ---- Lifecycle -----------------------------------------------------------
+      async close() {
+        await this.pool.end();
+      }
+    };
+  }
+});
+
+// src/data/store-factory.ts
+async function getStore(config2) {
+  if (instance) return instance;
+  if (config2.database?.type === "postgres" && config2.database.url) {
+    const { PostgresStore: PostgresStore2 } = await Promise.resolve().then(() => (init_postgres_store(), postgres_store_exports));
+    instance = new PostgresStore2(config2.database.url);
+  } else {
+    instance = new SqliteStore();
+  }
+  return instance;
+}
+function getStoreInstance() {
+  return instance;
+}
+var instance;
+var init_store_factory = __esm({
+  "src/data/store-factory.ts"() {
+    "use strict";
+    init_sqlite_store();
+    instance = null;
+  }
+});
+
+// src/ai/tool-handler.ts
+async function handleTool(name, input) {
+  const params = input;
+  switch (name) {
+    case "get_token_info": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const info = await adapter.getTokenInfo(address);
+      return {
+        address: info.address,
+        name: info.name,
+        symbol: info.symbol,
+        decimals: info.decimals,
+        totalSupply: info.totalSupply.toString()
+      };
+    }
+    case "analyze_wallet": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const analysis = await analyzeWallet(address, adapter);
+      return {
+        address: analysis.address,
+        chain: analysis.chain,
+        balance: analysis.balance.toString(),
+        transactionCount: analysis.transactionCount,
+        riskLevel: analysis.riskLevel,
+        patterns: analysis.patterns
+      };
+    }
+    case "check_rug_indicators": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? DEFAULT_CHAIN);
+      const adapter = getAdapter(chain);
+      await adapter.connect(void 0, getConfig().etherscanApiKey);
+      const indicators = await detectRugIndicators(address, adapter);
+      return {
+        isHoneypot: indicators.isHoneypot,
+        hasLiquidityLock: indicators.hasLiquidityLock,
+        ownerCanMint: indicators.ownerCanMint,
+        ownerCanPause: indicators.ownerCanPause,
+        hasBlacklist: indicators.hasBlacklist,
+        highSellTax: indicators.highSellTax,
+        riskScore: indicators.riskScore,
+        details: indicators.details
+      };
+    }
+    case "get_market_data": {
+      const symbol = String(params["symbol"] ?? "");
+      try {
+        const binance = await fetchTickerPrice(symbol);
+        const gecko = await fetchMarketData(symbol).catch(() => null);
+        return {
+          symbol: binance.symbol,
+          name: gecko?.name ?? binance.symbol,
+          price: binance.price,
+          priceChange24h: binance.change24h,
+          priceChange7d: gecko?.priceChange7d ?? null,
+          volume24h: gecko?.volume24h ?? null,
+          marketCap: gecko?.marketCap ?? null,
+          rank: gecko?.rank ?? null,
+          source: "binance+coingecko"
+        };
+      } catch {
+        const data = await fetchMarketData(symbol);
+        if (!data) {
+          return { error: `No market data found for "${symbol}"` };
+        }
+        return data;
+      }
+    }
+    case "search_upcoming_icos": {
+      const category = params["category"] ? String(params["category"]) : void 0;
+      const chain = params["chain"] ? String(params["chain"]) : void 0;
+      const roundType = params["roundType"] ? String(params["roundType"]) : void 0;
+      const projects = category || chain || roundType ? await searchICOs(void 0, category, chain, roundType) : await fetchUpcomingICOs();
+      return {
+        projects: projects.map((p) => ({
+          name: p.name,
+          category: p.category,
+          chain: p.chain,
+          roundType: p.roundType,
+          raisedAmount: p.raisedAmount,
+          valuation: p.valuation,
+          investors: p.investors.slice(0, 5),
+          startDate: p.startDate,
+          description: p.description,
+          website: p.website
+        }))
+      };
+    }
+    case "get_funding_history": {
+      const fundingName = String(params["name"] ?? "");
+      const type = String(params["type"] ?? "project");
+      if (type === "investor") {
+        const portfolio = await getInvestorPortfolio(fundingName);
+        return {
+          investor: fundingName,
+          investments: portfolio.map((p) => ({
+            name: p.name,
+            round: p.roundType,
+            amount: p.raisedAmount,
+            chain: p.chain,
+            category: p.category,
+            date: p.startDate
+          }))
+        };
+      }
+      const history = await getProjectFundingHistory(fundingName);
+      return {
+        project: history.name,
+        rounds: history.rounds.map((r) => ({
+          round: r.roundType,
+          amount: r.raisedAmount,
+          valuation: r.valuation,
+          investors: r.investors.slice(0, 5),
+          date: r.startDate,
+          previousRounds: r.previousRounds
+        }))
+      };
+    }
+    case "search_token_dex": {
+      const query = String(params["query"] ?? "");
+      const pairs = await fetchTokenFromDex(query);
+      return {
+        results: pairs.slice(0, 5).map((p) => ({
+          name: p.baseToken.name,
+          symbol: p.baseToken.symbol,
+          chain: p.chainId,
+          dex: p.dexId,
+          priceUsd: p.priceUsd,
+          volume24h: p.volume?.h24 ?? 0,
+          liquidity: p.liquidity?.usd ?? 0,
+          priceChange24h: p.priceChange?.h24 ?? 0,
+          marketCap: p.marketCap ?? p.fdv ?? null,
+          buys24h: p.txns?.h24?.buys ?? 0,
+          sells24h: p.txns?.h24?.sells ?? 0,
+          pairAddress: p.pairAddress,
+          url: p.url
+        }))
+      };
+    }
+    case "get_trending": {
+      const trending = await fetchTrendingTokens();
+      return {
+        trending: trending.slice(0, 10).map((t) => ({
+          name: t.name,
+          symbol: t.symbol,
+          chain: t.chain,
+          priceUsd: t.priceUsd,
+          priceChange24h: t.priceChange24h,
+          volume24h: t.volume24h,
+          marketCap: t.marketCap,
+          source: t.source,
+          url: t.url
+        }))
+      };
+    }
+    case "get_crypto_news": {
+      const symbol = params["symbol"] ? String(params["symbol"]) : void 0;
+      const news = await fetchCryptoNews(symbol, getConfig().cryptopanicApiKey);
+      return {
+        news: news.slice(0, 10).map((n) => ({
+          title: n.title,
+          sentiment: n.sentiment,
+          source: n.source.title,
+          publishedAt: n.publishedAt,
+          url: n.url
+        }))
+      };
+    }
+    case "get_raises": {
+      const raises = await fetchRecentRaises(30);
+      let filtered = raises;
+      if (params["category"]) {
+        const cat = String(params["category"]).toLowerCase();
+        filtered = filtered.filter(
+          (r) => r.category?.toLowerCase().includes(cat) || r.sector?.toLowerCase().includes(cat)
+        );
+      }
+      if (params["chain"]) {
+        const ch = String(params["chain"]).toLowerCase();
+        filtered = filtered.filter((r) => r.chains.some((c) => c.toLowerCase().includes(ch)));
+      }
+      return {
+        raises: filtered.slice(0, 10).map((r) => ({
+          name: r.name,
+          round: r.round,
+          amount: r.amount,
+          chains: r.chains,
+          sector: r.sector,
+          category: r.category,
+          leadInvestors: r.leadInvestors,
+          date: new Date(r.date * 1e3).toISOString().split("T")[0]
+        }))
+      };
+    }
+    case "get_token_security": {
+      const address = String(params["address"] ?? "");
+      const chain = String(params["chain"] ?? "ethereum");
+      const security = await checkTokenSecurity(address, chain);
+      if (!security) {
+        return { error: `No security data for ${address} on ${chain}` };
+      }
+      return {
+        contractAddress: security.contractAddress,
+        chain: security.chain,
+        riskLevel: security.riskLevel,
+        isHoneypot: security.isHoneypot,
+        isMintable: security.isMintable,
+        buyTax: security.buyTax,
+        sellTax: security.sellTax,
+        isOpenSource: security.isOpenSource,
+        isProxy: security.isProxy,
+        hiddenOwner: security.hiddenOwner,
+        cannotBuy: security.cannotBuy,
+        cannotSellAll: security.cannotSellAll,
+        isBlacklisted: security.isBlacklisted,
+        holderCount: security.holderCount,
+        lpHolderCount: security.lpHolderCount,
+        creatorPercent: security.creatorPercent,
+        ownerPercent: security.ownerPercent,
+        trustList: security.trustList
+      };
+    }
+    case "get_fear_greed": {
+      const data = await fetchFearGreedIndex(7);
+      return {
+        current: { value: data.current.value, classification: data.current.classification },
+        previous: data.previous ? { value: data.previous.value, classification: data.previous.classification } : null,
+        history: data.history.map((h) => ({
+          value: h.value,
+          classification: h.classification,
+          date: new Date(h.timestamp * 1e3).toISOString().split("T")[0]
+        }))
+      };
+    }
+    case "get_derivatives_data": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const [fundingResult, oiResult] = await Promise.allSettled([
+        fetchFundingRate(symbol),
+        fetchOpenInterest(symbol)
+      ]);
+      const result = { symbol: symbol.toUpperCase() };
+      if (fundingResult.status === "fulfilled") {
+        result["fundingRate"] = fundingResult.value.fundingRate;
+        result["fundingRatePct"] = `${(fundingResult.value.fundingRate * 100).toFixed(4)}%`;
+        result["markPrice"] = fundingResult.value.markPrice;
+      }
+      if (oiResult.status === "fulfilled") {
+        result["openInterest"] = oiResult.value.openInterest;
+        result["openInterestNotional"] = oiResult.value.notionalValue;
+      }
+      return result;
+    }
+    case "get_technical_analysis": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const timeframe = String(params["timeframe"] ?? "4h");
+      const ta = await analyzeTechnicals(symbol, timeframe);
+      return {
+        symbol: ta.symbol,
+        timeframe: ta.timeframe,
+        composite: ta.composite,
+        signals: ta.signals.map((s) => ({
+          name: s.name,
+          signal: s.signal,
+          strength: s.strength,
+          description: s.description
+        })),
+        indicators: {
+          rsi: ta.indicators.rsi ? Math.round(ta.indicators.rsi * 100) / 100 : null,
+          macd: ta.indicators.macd,
+          bollingerBands: ta.indicators.bollingerBands,
+          ema12: ta.indicators.ema12,
+          ema26: ta.indicators.ema26,
+          atr: ta.indicators.atr
+        }
+      };
+    }
+    case "get_prediction": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const prediction = await generatePrediction(symbol);
+      return {
+        symbol: prediction.symbol,
+        direction: prediction.direction,
+        confidence: prediction.confidence,
+        composite: prediction.composite,
+        timeframe: prediction.timeframe,
+        signals: prediction.signals,
+        reasoning: prediction.reasoning,
+        disclaimer: prediction.disclaimer
+      };
+    }
+    case "get_ml_prediction": {
+      const symbol = String(params["symbol"] ?? "BTC");
+      const mlClient2 = getMLClient();
+      if (!mlClient2) {
+        const prediction = await generatePrediction(symbol);
+        return {
+          ...prediction,
+          mlAvailable: false,
+          note: "ML sidecar not configured; using rule-based prediction"
+        };
+      }
+      const features = await buildFeatureVector(symbol);
+      const mlPred = await mlClient2.predict(features);
+      if (!mlPred) {
+        const prediction = await generatePrediction(symbol);
+        return {
+          ...prediction,
+          mlAvailable: false,
+          note: "ML sidecar unavailable; using rule-based prediction"
+        };
+      }
+      return {
+        symbol: mlPred.symbol,
+        direction: mlPred.direction,
+        probability: mlPred.probability,
+        confidence: mlPred.confidence,
+        model: mlPred.model,
+        horizon: mlPred.horizon,
+        mlAvailable: true,
+        features: {
+          rsi: features.rsi,
+          macdHistogram: features.macdHistogram,
+          bollingerPercentB: features.bollingerPercentB,
+          fundingRate: features.fundingRate,
+          fearGreed: features.fearGreed,
+          rsiSlope: features.rsiSlope,
+          volumeRatio: features.volumeRatio,
+          emaCrossoverPct: features.emaCrossoverPct,
+          atrPct: features.atrPct
+        }
+      };
+    }
+    case "get_model_accuracy": {
+      const model = String(params["model"] ?? "lstm-predictor");
+      const days = params["days"] ? Number(params["days"]) : 30;
+      const store = getStoreInstance();
+      if (!store) {
+        return { error: "DataStore not initialized. ML accuracy requires PostgreSQL backend." };
+      }
+      const accuracy = await store.getPredictionAccuracy(model, days);
+      return {
+        model: accuracy.model,
+        period: accuracy.period,
+        totalPredictions: accuracy.totalPredictions,
+        correctPredictions: accuracy.correctPredictions,
+        accuracy: `${(accuracy.accuracy * 100).toFixed(1)}%`,
+        byDirection: {
+          up: `${(accuracy.byDirection.up.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.up.correct}/${accuracy.byDirection.up.total})`,
+          down: `${(accuracy.byDirection.down.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.down.correct}/${accuracy.byDirection.down.total})`,
+          sideways: `${(accuracy.byDirection.sideways.accuracy * 100).toFixed(1)}% (${accuracy.byDirection.sideways.correct}/${accuracy.byDirection.sideways.total})`
+        }
+      };
+    }
+    case "create_agent": {
+      const agentName = String(params["name"] ?? "");
+      const strategy = String(params["strategy"] ?? "momentum");
+      const pairsRaw = String(params["pairs"] ?? "BTC,ETH");
+      const interval = params["interval"] ? Number(params["interval"]) : 60;
+      const agentPairs = pairsRaw.split(",").map((p) => p.trim().toUpperCase());
+      const agent = createAgent(agentName, strategy, agentPairs, interval);
+      return {
+        id: agent.id,
+        name: agent.name,
+        strategy: agent.strategy,
+        pairs: agent.pairs,
+        interval: agent.interval,
+        message: `Agent "${agent.name}" created. Use /agent start ${agent.name} to activate.`
+      };
+    }
+    case "list_agents": {
+      const agents = listAgents();
+      return {
+        agents: agents.map((a) => {
+          const status = getAgentStatus(a.id);
+          return {
+            name: a.name,
+            strategy: a.strategy,
+            pairs: a.pairs,
+            interval: a.interval,
+            status: status?.status ?? "idle",
+            cycleCount: status?.cycleCount ?? 0
+          };
+        })
+      };
+    }
+    case "get_agent_status": {
+      const agentName = String(params["name"] ?? "");
+      const agent = getAgentByName(agentName);
+      if (!agent) return { error: `Agent "${agentName}" not found` };
+      const state = getAgentStatus(agent.id);
+      if (!state) return { error: `Agent "${agentName}" not found` };
+      const decisions = getRecentDecisions(agent.id, 5);
+      return {
+        name: state.config.name,
+        status: state.status,
+        strategy: state.config.strategy,
+        pairs: state.config.pairs,
+        cycleCount: state.cycleCount,
+        error: state.error,
+        recentDecisions: decisions.map((d) => ({
+          symbol: d.symbol,
+          action: d.decision.action,
+          confidence: d.decision.confidence,
+          reasoning: d.decision.reasoning,
+          timestamp: new Date(d.timestamp).toISOString()
+        }))
+      };
+    }
+    default:
+      return { error: `Unknown tool: ${name}` };
+  }
+}
+var init_tool_handler = __esm({
+  "src/ai/tool-handler.ts"() {
+    "use strict";
+    init_registry();
+    init_loader();
+    init_constants();
+    init_wallet_analyzer();
+    init_rug_detector();
+    init_market();
+    init_ico_tracker();
+    init_cryptopanic();
+    init_defillama();
+    init_binance();
+    init_goplus();
+    init_fear_greed();
+    init_technical_analysis();
+    init_predictor();
+    init_agent();
+    init_client();
+    init_feature_engineer();
+    init_store_factory();
+  }
+});
+
+// src/ai/tools.ts
+var VIZZOR_TOOLS;
+var init_tools = __esm({
+  "src/ai/tools.ts"() {
+    "use strict";
+    VIZZOR_TOOLS = [
+      {
+        name: "get_token_info",
+        description: "Get on-chain token information including name, symbol, decimals, total supply, and top holders for a given contract address and chain.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The token contract address (e.g. 0x...)."
+            },
+            chain: {
+              type: "string",
+              description: 'The blockchain to query (e.g. "ethereum", "bsc", "polygon", "arbitrum").'
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "analyze_wallet",
+        description: "Analyze a wallet address for transaction patterns, token holdings, DeFi interactions, and behavioral signals such as accumulation or distribution phases.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The wallet address to analyze."
+            },
+            chain: {
+              type: "string",
+              description: 'The blockchain the wallet resides on (e.g. "ethereum", "bsc").'
+            },
+            depth: {
+              type: "number",
+              description: "How many recent transactions to inspect. Defaults to 100."
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "check_rug_indicators",
+        description: "Check a token for common rug pull indicators including honeypot detection, liquidity locks, ownership status, hidden mints, and holder concentration.",
+        input_schema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description: "The token contract address to check."
+            },
+            chain: {
+              type: "string",
+              description: "The blockchain the token is deployed on."
+            }
+          },
+          required: ["address", "chain"]
+        }
+      },
+      {
+        name: "get_market_data",
+        description: "Get LIVE current market data for a token including price, 24h volume, market cap, price change percentages, and circulating supply. Returns real-time data \u2014 never quote prices from training data.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token ticker symbol (e.g. "ETH", "BTC", "UNI").'
+            },
+            currency: {
+              type: "string",
+              description: 'The fiat currency for price quotes. Defaults to "usd".'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "search_upcoming_icos",
+        description: "Search for CURRENT upcoming ICOs, token launches, and fundraising rounds filtered by category, blockchain, or round type. Returns LIVE data from DeFiLlama raises and Pump.fun launches, updated daily. MUST call for any ICO/launch question \u2014 training data is stale.",
+        input_schema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              description: 'Filter by project category (e.g. "defi", "gaming", "infrastructure", "nft", "ai").'
+            },
+            chain: {
+              type: "string",
+              description: 'Filter by blockchain (e.g. "ethereum", "solana", "bsc").'
+            },
+            roundType: {
+              type: "string",
+              description: 'Filter by funding round type (e.g. "Seed", "Pre-Seed", "Series A", "Series B", "Token Launch").'
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results to return. Defaults to 10."
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "get_funding_history",
+        description: "Get complete funding history for a project by name. Returns all known fundraising rounds with amounts, investors, valuations, and dates. Also works for looking up an investor portfolio.",
+        input_schema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Project name or investor name to look up."
+            },
+            type: {
+              type: "string",
+              description: 'Type of lookup: "project" for project funding history, "investor" for investor portfolio. Defaults to "project".'
+            }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "search_token_dex",
+        description: "Search for any token on decentralized exchanges via DexScreener. Returns real-time price, volume, liquidity, buy/sell counts, pair info. Works for all tokens including meme coins and newly launched tokens.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Token name, symbol, or contract address to search for."
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "get_trending",
+        description: "Get REAL-TIME trending and hot tokens from DexScreener (boosted tokens) and CoinGecko trending combined. Returns what the market is excited about RIGHT NOW \u2014 trends change hourly. Always call for trending/hot token questions.",
+        input_schema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "get_crypto_news",
+        description: "Get LIVE latest crypto news with sentiment analysis for a specific token or the market in general. Returns current headlines from CryptoPanic \u2014 MUST call for news questions, training data is outdated.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'Token symbol to filter news for (e.g. "BTC", "ETH", "SOL"). Omit for general crypto news.'
+            }
+          },
+          required: []
+        }
+      },
       {
         name: "get_raises",
         description: "Get LIVE recent crypto fundraising rounds, venture capital investments, and token launches. Returns CURRENT data updated daily from DeFiLlama \u2014 always call this for ICO/funding questions, never use training data.",
@@ -6652,35 +7277,67 @@ var init_tools = __esm({
         }
       },
       {
-        name: "get_technical_analysis",
-        description: "Run technical analysis on a token: RSI, MACD, Bollinger Bands, EMA crossovers, ATR, OBV. Returns individual indicator signals and a composite direction with confidence.",
+        name: "get_technical_analysis",
+        description: "Run technical analysis on a token: RSI, MACD, Bollinger Bands, EMA crossovers, ATR, OBV. Returns individual indicator signals and a composite direction with confidence.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+            },
+            timeframe: {
+              type: "string",
+              description: 'Kline interval: "1h", "4h", "1d". Defaults to "4h".'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_prediction",
+        description: "Generate a multi-signal composite prediction combining technical analysis (40%), sentiment (20%), derivatives (20%), trend (15%), and macro (5%). Returns direction, confidence, composite score, and reasoning.",
+        input_schema: {
+          type: "object",
+          properties: {
+            symbol: {
+              type: "string",
+              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+            }
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "get_ml_prediction",
+        description: "Get an ML-enhanced prediction using LSTM/Random Forest models from the ML sidecar. Returns direction, probability, model confidence, and feature importance. Falls back to rule-based prediction if ML sidecar is unavailable.",
         input_schema: {
           type: "object",
           properties: {
             symbol: {
               type: "string",
               description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
-            },
-            timeframe: {
-              type: "string",
-              description: 'Kline interval: "1h", "4h", "1d". Defaults to "4h".'
             }
           },
           required: ["symbol"]
         }
       },
       {
-        name: "get_prediction",
-        description: "Generate a multi-signal composite prediction combining technical analysis (40%), sentiment (20%), derivatives (20%), trend (15%), and macro (5%). Returns direction, confidence, composite score, and reasoning.",
+        name: "get_model_accuracy",
+        description: "Get historical accuracy metrics for ML prediction models. Shows total predictions, accuracy percentage, and breakdown by direction (up/down/sideways).",
         input_schema: {
           type: "object",
           properties: {
-            symbol: {
+            model: {
               type: "string",
-              description: 'The token symbol (e.g. "BTC", "ETH", "SOL").'
+              description: 'Model name (e.g. "lstm-predictor", "signal-classifier"). Defaults to "lstm-predictor".'
+            },
+            days: {
+              type: "number",
+              description: "Number of days to look back for accuracy stats. Defaults to 30."
             }
           },
-          required: ["symbol"]
+          required: []
         }
       },
       {
@@ -7176,1391 +7833,964 @@ Cycles: ${state?.cycleCount ?? 0} | Interval: ${agent.interval}s`,
       inline: false
     });
   }
-  await interaction.editReply({ embeds: [embed] });
-}
-async function handleAgentStartCommand(interaction) {
-  const name = interaction.options.getString("name", true);
-  const agent = getAgentByName(name);
-  if (!agent) {
-    await interaction.reply({
-      content: `Agent "${name}" not found. Use \`/agent_list\` to see your agents.`,
-      ephemeral: true
-    });
-    return;
-  }
-  const state = startAgent(agent.id);
-  await interaction.reply(
-    `\u{1F7E2} Agent "${state.config.name}" started. Monitoring ${state.config.pairs.join(", ")}.`
-  );
-}
-async function handleAgentStopCommand(interaction) {
-  const name = interaction.options.getString("name", true);
-  const agent = getAgentByName(name);
-  if (!agent) {
-    await interaction.reply({
-      content: `Agent "${name}" not found.`,
-      ephemeral: true
-    });
-    return;
-  }
-  const state = stopAgent(agent.id);
-  await interaction.reply(
-    `\u{1F534} Agent "${state.config.name}" stopped after ${state.cycleCount} cycles.`
-  );
-}
-async function handleAgentStatusCommand(interaction) {
-  await interaction.deferReply();
-  const name = interaction.options.getString("name", true);
-  const agent = getAgentByName(name);
-  if (!agent) {
-    await interaction.editReply(`Agent "${name}" not found.`);
-    return;
-  }
-  const state = getAgentStatus(agent.id);
-  if (!state) {
-    await interaction.editReply(`Agent "${name}" not found.`);
-    return;
-  }
-  const statusColor = state.status === "running" ? 65280 : state.status === "stopped" ? 16711680 : 8421504;
-  const statusEmoji = state.status === "running" ? "\u{1F7E2}" : state.status === "stopped" ? "\u{1F534}" : "\u26AA";
-  const embed = new EmbedBuilder().setTitle(`\u{1F916} Agent: ${state.config.name}`).setColor(statusColor).addFields(
-    { name: "Status", value: `${statusEmoji} ${state.status}`, inline: true },
-    { name: "Strategy", value: state.config.strategy, inline: true },
-    { name: "Pairs", value: state.config.pairs.join(", "), inline: true },
-    { name: "Interval", value: `${state.config.interval}s`, inline: true },
-    { name: "Cycles", value: String(state.cycleCount), inline: true }
-  ).setTimestamp();
-  if (state.error) {
-    embed.addFields({ name: "Error", value: state.error });
-  }
-  const decisions = getRecentDecisions(agent.id, 5);
-  if (decisions.length > 0) {
-    const decisionText = decisions.map((d) => {
-      const actionEmoji = d.decision.action === "buy" ? "\u{1F7E2}" : d.decision.action === "sell" ? "\u{1F534}" : "\u26AA";
-      const time = new Date(d.timestamp).toLocaleString();
-      return `${actionEmoji} ${d.symbol} ${d.decision.action.toUpperCase()} (${d.decision.confidence}%) \u2014 ${time}`;
-    }).join("\n");
-    embed.addFields({ name: "Recent Decisions", value: decisionText.slice(0, 1024) });
-  }
-  await interaction.editReply({ embeds: [embed] });
-}
-async function handleAgentDeleteCommand(interaction) {
-  const name = interaction.options.getString("name", true);
-  const agent = getAgentByName(name);
-  if (!agent) {
-    await interaction.reply({
-      content: `Agent "${name}" not found.`,
-      ephemeral: true
-    });
-    return;
-  }
-  deleteAgent(agent.id);
-  await interaction.reply(`\u{1F5D1} Agent "${name}" deleted.`);
-}
-var init_commands = __esm({
-  "src/discord/commands/index.ts"() {
-    "use strict";
-    init_registry();
-    init_loader();
-    init_project_analyzer();
-    init_risk_scorer();
-    init_wallet_analyzer();
-    init_contract_auditor();
-    init_market();
-    init_ico_tracker();
-    init_defillama();
-    init_binance();
-    init_predictor();
-    init_agent();
-    init_rate_limit();
-  }
-});
-
-// src/discord/bot.ts
-var bot_exports = {};
-__export(bot_exports, {
-  startDiscordBot: () => startDiscordBot
-});
-import { Client, GatewayIntentBits, REST, Routes } from "discord.js";
-async function startDiscordBot() {
-  const config2 = loadConfig();
-  const token = config2.discordToken;
-  if (!token) {
-    throw new Error("Discord token not configured. Run: vizzor config set discordToken <token>");
-  }
-  setConfig(config2);
-  setToolHandler(handleTool);
-  const client2 = new Client({
-    intents: [
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent
-    ]
-  });
-  startRateLimitCleanup();
-  client2.once("ready", async (readyClient) => {
-    console.log(`Discord bot logged in as ${readyClient.user.tag}`);
-    const rest = new REST({ version: "10" }).setToken(token);
-    const commands = registerSlashCommands();
-    if (config2.discordGuildId) {
-      await rest.put(Routes.applicationGuildCommands(readyClient.user.id, config2.discordGuildId), {
-        body: commands
-      });
-    } else {
-      await rest.put(Routes.applicationCommands(readyClient.user.id), {
-        body: commands
-      });
-    }
-    console.log("Discord slash commands registered");
-  });
-  client2.on("interactionCreate", async (interaction) => {
-    if (!interaction.isChatInputCommand()) return;
-    await handleSlashCommand(interaction);
-  });
-  client2.on("messageCreate", async (message) => {
-    if (message.author.bot) return;
-    if (!client2.user || !message.mentions.has(client2.user)) return;
-    const text = message.content.replace(/<@!?\d+>/g, "").trim();
-    if (!text) {
-      await message.reply(
-        "Mention me with a question! e.g. `@Vizzor what is BTC price?`\nOr use slash commands: `/scan` `/trends` `/track` `/ico` `/audit` `/help`"
-      );
-      return;
-    }
-    await message.reply("\u{1F52E} Analyzing...");
-    try {
-      const response = await analyze(buildChatSystemPrompt(), text, VIZZOR_TOOLS);
-      const chunks = splitMessage(response, 1900);
-      for (const chunk of chunks) {
-        await message.reply(chunk);
-      }
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      await message.reply(`Analysis failed: ${msg}`);
-    }
-  });
-  await client2.login(token);
-}
-var init_bot = __esm({
-  "src/discord/bot.ts"() {
-    "use strict";
-    init_loader();
-    init_client();
-    init_tool_handler();
-    init_tools();
-    init_chat();
-    init_message_split();
-    init_commands();
-    init_rate_limit();
-  }
-});
-
-// src/telegram/formatters/market.ts
-function escapeMarkdown(text) {
-  return text.replace(/([_*[\]()~`>#+\-=|{}.!\\<>])/g, "\\$1");
-}
-function formatChange(change) {
-  const sign = change > 0 ? "\\+" : "";
-  const emoji = change > 0 ? "\u{1F7E2}" : change < 0 ? "\u{1F534}" : "\u26AA";
-  return `${emoji} ${sign}${escapeMarkdown(change.toFixed(2))}%`;
-}
-function formatVolume(volume) {
-  if (volume >= 1e9) return escapeMarkdown(`$${(volume / 1e9).toFixed(2)}B`);
-  if (volume >= 1e6) return escapeMarkdown(`$${(volume / 1e6).toFixed(2)}M`);
-  if (volume >= 1e3) return escapeMarkdown(`$${(volume / 1e3).toFixed(1)}K`);
-  return escapeMarkdown(`$${volume.toFixed(0)}`);
-}
-function formatTrending(items) {
-  const lines = ["*\u{1F525} Trending Tokens*", ""];
-  for (const t of items.slice(0, 10)) {
-    lines.push(
-      `\u2022 *${escapeMarkdown(t.symbol)}* \\(${escapeMarkdown(t.chain)}\\)`,
-      `  \u{1F4B2}${escapeMarkdown(t.priceUsd)} ${formatChange(t.priceChange24h)}`,
-      `  Vol: ${formatVolume(t.volume24h)} _\\[${escapeMarkdown(t.source)}\\]_`,
-      ""
-    );
-  }
-  return lines.join("\n");
-}
-function formatICOs(icos) {
-  const lines = ["*\u{1F680} Upcoming ICOs \\& Raises*", ""];
-  for (const ico of icos.slice(0, 10)) {
-    const amount = ico.amount ? escapeMarkdown(`$${(ico.amount / 1e6).toFixed(1)}M`) : "undisclosed";
-    const chains = ico.chains.length > 0 ? escapeMarkdown(ico.chains.join(", ")) : "multi\\-chain";
-    lines.push(
-      `\u2022 *${escapeMarkdown(ico.name)}* \u2014 ${escapeMarkdown(ico.round)} \\(${amount}\\)`,
-      `  ${chains} \\| ${escapeMarkdown(ico.date)}`
-    );
-    if (ico.leadInvestors.length > 0) {
-      lines.push(`  Led by: ${escapeMarkdown(ico.leadInvestors.join(", "))}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function formatAudit(contract, overallRisk, findings) {
-  const riskEmoji = overallRisk === "low" ? "\u{1F7E2}" : overallRisk === "medium" ? "\u{1F7E1}" : overallRisk === "high" ? "\u{1F7E0}" : "\u{1F534}";
-  const lines = [
-    `*\u{1F50D} Contract Audit*`,
-    `Address: \`${escapeMarkdown(contract)}\``,
-    `${riskEmoji} Risk: *${escapeMarkdown(overallRisk.toUpperCase())}*`,
-    ""
-  ];
-  if (findings.length > 0) {
-    lines.push("*Findings:*");
-    for (const f of findings) {
-      const sevEmoji = f.severity === "critical" ? "\u{1F534}" : f.severity === "high" ? "\u{1F7E0}" : f.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
-      lines.push(`${sevEmoji} *${escapeMarkdown(f.title)}*: ${escapeMarkdown(f.description)}`);
-    }
-  } else {
-    lines.push("\u2705 No significant findings\\.");
-  }
-  lines.push("", "_Not financial advice\\. DYOR\\._");
-  return lines.join("\n");
+  await interaction.editReply({ embeds: [embed] });
 }
-function formatWalletAnalysis(address, chain, balance, txCount, riskLevel, patterns) {
-  const riskEmoji = riskLevel === "low" ? "\u{1F7E2}" : riskLevel === "medium" ? "\u{1F7E1}" : riskLevel === "high" ? "\u{1F7E0}" : "\u{1F534}";
-  const lines = [
-    `*\u{1F45B} Wallet Analysis*`,
-    `Address: \`${escapeMarkdown(address)}\``,
-    `Chain: ${escapeMarkdown(chain)}`,
-    `Balance: ${escapeMarkdown(balance)} ETH`,
-    `Transactions: ${escapeMarkdown(String(txCount))}`,
-    `${riskEmoji} Risk: *${escapeMarkdown(riskLevel.toUpperCase())}*`,
-    ""
-  ];
-  if (patterns.length > 0) {
-    lines.push("*Patterns:*");
-    for (const p of patterns) {
-      lines.push(`\u2022 \\[${escapeMarkdown(p.severity)}\\] ${escapeMarkdown(p.description)}`);
-    }
-  } else {
-    lines.push("No unusual patterns detected\\.");
+async function handleAgentStartCommand(interaction) {
+  const name = interaction.options.getString("name", true);
+  const agent = getAgentByName(name);
+  if (!agent) {
+    await interaction.reply({
+      content: `Agent "${name}" not found. Use \`/agent_list\` to see your agents.`,
+      ephemeral: true
+    });
+    return;
   }
-  return lines.join("\n");
+  const state = startAgent(agent.id);
+  await interaction.reply(
+    `\u{1F7E2} Agent "${state.config.name}" started. Monitoring ${state.config.pairs.join(", ")}.`
+  );
 }
-var init_market2 = __esm({
-  "src/telegram/formatters/market.ts"() {
-    "use strict";
+async function handleAgentStopCommand(interaction) {
+  const name = interaction.options.getString("name", true);
+  const agent = getAgentByName(name);
+  if (!agent) {
+    await interaction.reply({
+      content: `Agent "${name}" not found.`,
+      ephemeral: true
+    });
+    return;
   }
-});
-
-// src/telegram/commands/index.ts
-function registerCommands(bot) {
-  bot.command(
-    "start",
-    (ctx) => ctx.reply(
-      "*Welcome to Vizzor* \u2014 AI\\-powered crypto chronovisor\\.\n\n*Commands:*\n/scan \\<address\\> \u2014 Analyze a project\n/trends \u2014 Trending tokens \\+ market movers\n/track \\<wallet\\> \u2014 Wallet forensics\n/ico \u2014 Upcoming ICOs \\& raises\n/audit \\<contract\\> \u2014 Smart contract audit\n/price \\<symbol\\> \u2014 Quick price check\n/predict \\<symbol\\> \u2014 AI prediction\n/wallet \\<address\\> \u2014 Wallet balance\n/agent \u2014 Trading agent management\n/help \u2014 Show all commands\n\n_Send any message for AI\\-powered analysis_",
-      { parse_mode: "MarkdownV2" }
-    )
-  );
-  bot.command(
-    "help",
-    (ctx) => ctx.reply(
-      "*Vizzor Commands*\n\n*Analysis:*\n/scan \\<address\\> \u2014 Analyze token/project risk\n/track \\<wallet\\> \u2014 Wallet analysis \\& forensics\n/trends \u2014 Trending tokens from DexScreener\n/ico \u2014 Upcoming ICOs \\& fundraising rounds\n/audit \\<contract\\> \u2014 Smart contract audit\n\n*Quick Commands:*\n/price \\<symbol\\> \u2014 Live price check\n/predict \\<symbol\\> \u2014 AI prediction with signals\n/wallet \\<address\\> \u2014 ETH wallet balance\n\n*Agent Management:*\n/agent\\_create \\<name\\> \\<strategy\\> \\<pairs\\>\n/agent\\_list \u2014 List all agents\n/agent\\_start \\<name\\> \u2014 Start an agent\n/agent\\_stop \\<name\\> \u2014 Stop an agent\n/agent\\_status \\<name\\> \u2014 Agent status \\& decisions\n/agent\\_delete \\<name\\> \u2014 Delete an agent\n\n_Send any message for AI\\-powered analysis_",
-      { parse_mode: "MarkdownV2" }
-    )
+  const state = stopAgent(agent.id);
+  await interaction.reply(
+    `\u{1F534} Agent "${state.config.name}" stopped after ${state.cycleCount} cycles.`
   );
-  bot.command("scan", handleScan2);
-  bot.command("trends", handleTrends2);
-  bot.command("track", handleTrack2);
-  bot.command("ico", handleIco);
-  bot.command("audit", handleAudit2);
-  bot.command("price", handlePrice);
-  bot.command("predict", handlePredict);
-  bot.command("wallet", handleWallet);
-  bot.command("agent", handleAgentHelp);
-  bot.command("agent_create", handleAgentCreate);
-  bot.command("agent_list", handleAgentList);
-  bot.command("agent_start", handleAgentStart);
-  bot.command("agent_stop", handleAgentStop);
-  bot.command("agent_status", handleAgentStatus);
-  bot.command("agent_delete", handleAgentDelete);
 }
-async function handleScan2(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const project = args2[0];
-  if (!project) {
-    await ctx.reply("Usage: /scan <project_address>", { parse_mode: void 0 });
+async function handleAgentStatusCommand(interaction) {
+  await interaction.deferReply();
+  const name = interaction.options.getString("name", true);
+  const agent = getAgentByName(name);
+  if (!agent) {
+    await interaction.editReply(`Agent "${name}" not found.`);
     return;
   }
-  await ctx.reply("\u{1F50D} Scanning project...");
-  try {
-    const adapter = getAdapter("ethereum");
-    await adapter.connect(void 0, getConfig().etherscanApiKey);
-    const analysis = await analyzeProject(project, adapter);
-    const risk = assessRisk(analysis);
-    await adapter.disconnect();
-    const riskEmoji = risk.level === "low" ? "\u{1F7E2}" : risk.level === "medium" ? "\u{1F7E1}" : risk.level === "high" ? "\u{1F7E0}" : "\u{1F534}";
-    let message = `*Project Analysis*
-
-`;
-    message += `${riskEmoji} Risk: ${risk.score}/100 \\(${escapeMarkdown(risk.level.toUpperCase())}\\)
-`;
-    message += `${escapeMarkdown(risk.summary)}
-`;
-    if (analysis.token) {
-      message += `
-Token: ${escapeMarkdown(analysis.token.name)} \\(${escapeMarkdown(analysis.token.symbol)}\\)`;
-    }
-    if (risk.factors.length > 0) {
-      message += "\n\n*Risk Factors*\n";
-      for (const factor of risk.factors) {
-        message += `\u2022 ${escapeMarkdown(factor)}
-`;
-      }
-    }
-    message += "\n_Not financial advice\\. DYOR\\._";
-    await ctx.reply(message, { parse_mode: "MarkdownV2" });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Error: ${msg}`);
+  const state = getAgentStatus(agent.id);
+  if (!state) {
+    await interaction.editReply(`Agent "${name}" not found.`);
+    return;
   }
-}
-async function handleTrends2(ctx) {
-  await ctx.reply("\u{1F4CA} Fetching trends...");
-  try {
-    const trending = await fetchTrendingTokens();
-    if (trending.length === 0) {
-      await ctx.reply("No trending data available right now.");
-      return;
-    }
-    const formatted = formatTrending(
-      trending.slice(0, 10).map((t) => ({
-        name: t.name,
-        symbol: t.symbol,
-        chain: t.chain,
-        priceUsd: t.priceUsd,
-        priceChange24h: t.priceChange24h,
-        volume24h: t.volume24h,
-        source: t.source
-      }))
-    );
-    await ctx.reply(formatted + "\n\n_Live data from DexScreener \\& CoinGecko_", {
-      parse_mode: "MarkdownV2"
-    });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to fetch trends: ${msg}`);
+  const statusColor = state.status === "running" ? 65280 : state.status === "stopped" ? 16711680 : 8421504;
+  const statusEmoji = state.status === "running" ? "\u{1F7E2}" : state.status === "stopped" ? "\u{1F534}" : "\u26AA";
+  const embed = new EmbedBuilder().setTitle(`\u{1F916} Agent: ${state.config.name}`).setColor(statusColor).addFields(
+    { name: "Status", value: `${statusEmoji} ${state.status}`, inline: true },
+    { name: "Strategy", value: state.config.strategy, inline: true },
+    { name: "Pairs", value: state.config.pairs.join(", "), inline: true },
+    { name: "Interval", value: `${state.config.interval}s`, inline: true },
+    { name: "Cycles", value: String(state.cycleCount), inline: true }
+  ).setTimestamp();
+  if (state.error) {
+    embed.addFields({ name: "Error", value: state.error });
+  }
+  const decisions = getRecentDecisions(agent.id, 5);
+  if (decisions.length > 0) {
+    const decisionText = decisions.map((d) => {
+      const actionEmoji = d.decision.action === "buy" ? "\u{1F7E2}" : d.decision.action === "sell" ? "\u{1F534}" : "\u26AA";
+      const time = new Date(d.timestamp).toLocaleString();
+      return `${actionEmoji} ${d.symbol} ${d.decision.action.toUpperCase()} (${d.decision.confidence}%) \u2014 ${time}`;
+    }).join("\n");
+    embed.addFields({ name: "Recent Decisions", value: decisionText.slice(0, 1024) });
   }
+  await interaction.editReply({ embeds: [embed] });
 }
-async function handleTrack2(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const wallet = args2[0];
-  if (!wallet) {
-    await ctx.reply("Usage: /track <wallet_address>", { parse_mode: void 0 });
+async function handleAgentDeleteCommand(interaction) {
+  const name = interaction.options.getString("name", true);
+  const agent = getAgentByName(name);
+  if (!agent) {
+    await interaction.reply({
+      content: `Agent "${name}" not found.`,
+      ephemeral: true
+    });
     return;
   }
-  await ctx.reply("\u{1F45B} Analyzing wallet...");
-  try {
-    const adapter = getAdapter("ethereum");
-    await adapter.connect(void 0, getConfig().etherscanApiKey);
-    const analysis = await analyzeWallet(wallet, adapter);
-    await adapter.disconnect();
-    const formatted = formatWalletAnalysis(
-      analysis.address,
-      analysis.chain,
-      analysis.balance.toString(),
-      analysis.transactionCount,
-      analysis.riskLevel,
-      analysis.patterns
-    );
-    await ctx.reply(formatted, { parse_mode: "MarkdownV2" });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Wallet analysis failed: ${msg}`);
-  }
+  deleteAgent(agent.id);
+  await interaction.reply(`\u{1F5D1} Agent "${name}" deleted.`);
 }
-async function handleIco(ctx) {
-  await ctx.reply("\u{1F680} Fetching ICOs and raises...");
-  try {
-    const [icosResult, raisesResult] = await Promise.allSettled([
-      fetchUpcomingICOs(),
-      fetchRecentRaises(30)
-    ]);
-    const icos = icosResult.status === "fulfilled" ? icosResult.value : [];
-    const raises = raisesResult.status === "fulfilled" ? raisesResult.value : [];
-    const items = [
-      ...raises.slice(0, 10).map((r) => ({
-        name: r.name,
-        round: r.round,
-        amount: r.amount,
-        chains: r.chains,
-        leadInvestors: r.leadInvestors,
-        date: new Date(r.date * 1e3).toISOString().split("T")[0] ?? ""
-      }))
-    ];
-    const raiseNames = new Set(items.map((i) => i.name.toLowerCase()));
-    for (const ico of icos.slice(0, 5)) {
-      if (!raiseNames.has(ico.name.toLowerCase())) {
-        items.push({
-          name: ico.name,
-          round: ico.status,
-          amount: null,
-          chains: [ico.chain ?? "multi-chain"],
-          leadInvestors: [],
-          date: ico.startDate ?? ""
-        });
-      }
+var init_commands = __esm({
+  "src/discord/commands/index.ts"() {
+    "use strict";
+    init_registry();
+    init_loader();
+    init_project_analyzer();
+    init_risk_scorer();
+    init_wallet_analyzer();
+    init_contract_auditor();
+    init_market();
+    init_ico_tracker();
+    init_defillama();
+    init_binance();
+    init_predictor();
+    init_agent();
+    init_rate_limit();
+  }
+});
+
+// src/discord/bot.ts
+var bot_exports = {};
+__export(bot_exports, {
+  startDiscordBot: () => startDiscordBot
+});
+import { Client, GatewayIntentBits, REST, Routes } from "discord.js";
+async function startDiscordBot() {
+  const config2 = loadConfig();
+  const token = config2.discordToken;
+  if (!token) {
+    throw new Error("Discord token not configured. Run: vizzor config set discordToken <token>");
+  }
+  setConfig(config2);
+  setToolHandler(handleTool);
+  const client2 = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent
+    ]
+  });
+  startRateLimitCleanup();
+  client2.once("ready", async (readyClient) => {
+    console.log(`Discord bot logged in as ${readyClient.user.tag}`);
+    const rest = new REST({ version: "10" }).setToken(token);
+    const commands = registerSlashCommands();
+    if (config2.discordGuildId) {
+      await rest.put(Routes.applicationGuildCommands(readyClient.user.id, config2.discordGuildId), {
+        body: commands
+      });
+    } else {
+      await rest.put(Routes.applicationCommands(readyClient.user.id), {
+        body: commands
+      });
     }
-    if (items.length === 0) {
-      await ctx.reply("No ICO or fundraising data available right now.");
+    console.log("Discord slash commands registered");
+  });
+  client2.on("interactionCreate", async (interaction) => {
+    if (!interaction.isChatInputCommand()) return;
+    await handleSlashCommand(interaction);
+  });
+  client2.on("messageCreate", async (message) => {
+    if (message.author.bot) return;
+    if (!client2.user || !message.mentions.has(client2.user)) return;
+    const text = message.content.replace(/<@!?\d+>/g, "").trim();
+    if (!text) {
+      await message.reply(
+        "Mention me with a question! e.g. `@Vizzor what is BTC price?`\nOr use slash commands: `/scan` `/trends` `/track` `/ico` `/audit` `/help`"
+      );
       return;
     }
-    const formatted = formatICOs(items);
-    await ctx.reply(formatted + "\n_Data from DeFiLlama \\& Pump\\.fun_", {
-      parse_mode: "MarkdownV2"
-    });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to fetch ICOs: ${msg}`);
-  }
+    await message.reply("\u{1F52E} Analyzing...");
+    try {
+      const response = await analyze(buildChatSystemPrompt(), text, VIZZOR_TOOLS);
+      const chunks = splitMessage(response, 1900);
+      for (const chunk of chunks) {
+        await message.reply(chunk);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      await message.reply(`Analysis failed: ${msg}`);
+    }
+  });
+  await client2.login(token);
 }
-async function handleAudit2(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const contract = args2[0];
-  if (!contract) {
-    await ctx.reply("Usage: /audit <contract_address>", { parse_mode: void 0 });
-    return;
+var init_bot = __esm({
+  "src/discord/bot.ts"() {
+    "use strict";
+    init_loader();
+    init_client2();
+    init_tool_handler();
+    init_tools();
+    init_chat();
+    init_message_split();
+    init_commands();
+    init_rate_limit();
   }
-  await ctx.reply("\u{1F50D} Auditing contract...");
-  try {
-    const adapter = getAdapter("ethereum");
-    await adapter.connect(void 0, getConfig().etherscanApiKey);
-    const result = await auditContract(contract, adapter);
-    await adapter.disconnect();
-    const formatted = formatAudit(
-      contract,
-      result.overallRisk,
-      result.findings.map((f) => ({
-        severity: f.severity,
-        title: f.title,
-        description: f.description
-      }))
+});
+
+// src/telegram/formatters/market.ts
+function escapeMarkdown(text) {
+  return text.replace(/([_*[\]()~`>#+\-=|{}.!\\<>])/g, "\\$1");
+}
+function formatChange(change) {
+  const sign = change > 0 ? "\\+" : "";
+  const emoji = change > 0 ? "\u{1F7E2}" : change < 0 ? "\u{1F534}" : "\u26AA";
+  return `${emoji} ${sign}${escapeMarkdown(change.toFixed(2))}%`;
+}
+function formatVolume(volume) {
+  if (volume >= 1e9) return escapeMarkdown(`$${(volume / 1e9).toFixed(2)}B`);
+  if (volume >= 1e6) return escapeMarkdown(`$${(volume / 1e6).toFixed(2)}M`);
+  if (volume >= 1e3) return escapeMarkdown(`$${(volume / 1e3).toFixed(1)}K`);
+  return escapeMarkdown(`$${volume.toFixed(0)}`);
+}
+function formatTrending(items) {
+  const lines = ["*\u{1F525} Trending Tokens*", ""];
+  for (const t of items.slice(0, 10)) {
+    lines.push(
+      `\u2022 *${escapeMarkdown(t.symbol)}* \\(${escapeMarkdown(t.chain)}\\)`,
+      `  \u{1F4B2}${escapeMarkdown(t.priceUsd)} ${formatChange(t.priceChange24h)}`,
+      `  Vol: ${formatVolume(t.volume24h)} _\\[${escapeMarkdown(t.source)}\\]_`,
+      ""
     );
-    await ctx.reply(formatted, { parse_mode: "MarkdownV2" });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Audit failed: ${msg}`);
   }
+  return lines.join("\n");
 }
-async function handlePrice(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const symbol = args2[0]?.toUpperCase();
-  if (!symbol) {
-    await ctx.reply("Usage: /price <symbol>\nExample: /price BTC");
-    return;
-  }
-  try {
-    const ticker = await fetchTickerPrice(symbol);
-    const changeEmoji = ticker.change24h >= 0 ? "\u{1F7E2}" : "\u{1F534}";
-    const changeSign = ticker.change24h >= 0 ? "+" : "";
-    await ctx.reply(
-      `\u{1F4B0} ${ticker.symbol}
-Price: $${ticker.price.toLocaleString()}
-${changeEmoji} 24h: ${changeSign}${ticker.change24h.toFixed(2)}%
-
-Live from Binance`
+function formatICOs(icos) {
+  const lines = ["*\u{1F680} Upcoming ICOs \\& Raises*", ""];
+  for (const ico of icos.slice(0, 10)) {
+    const amount = ico.amount ? escapeMarkdown(`$${(ico.amount / 1e6).toFixed(1)}M`) : "undisclosed";
+    const chains = ico.chains.length > 0 ? escapeMarkdown(ico.chains.join(", ")) : "multi\\-chain";
+    lines.push(
+      `\u2022 *${escapeMarkdown(ico.name)}* \u2014 ${escapeMarkdown(ico.round)} \\(${amount}\\)`,
+      `  ${chains} \\| ${escapeMarkdown(ico.date)}`
     );
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Price check failed: ${msg}`);
+    if (ico.leadInvestors.length > 0) {
+      lines.push(`  Led by: ${escapeMarkdown(ico.leadInvestors.join(", "))}`);
+    }
+    lines.push("");
   }
+  return lines.join("\n");
 }
-async function handlePredict(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const symbol = args2[0]?.toUpperCase();
-  if (!symbol) {
-    await ctx.reply("Usage: /predict <symbol>\nExample: /predict ETH");
-    return;
-  }
-  await ctx.reply(`\u{1F52E} Generating prediction for ${symbol}...`);
-  try {
-    const prediction = await generatePrediction(symbol);
-    const dirEmoji = prediction.direction === "up" ? "\u{1F7E2}" : prediction.direction === "down" ? "\u{1F534}" : "\u26AA";
-    let msg = `\u{1F52E} ${prediction.symbol} Prediction
-
-`;
-    msg += `${dirEmoji} Direction: ${prediction.direction.toUpperCase()}
-`;
-    msg += `\u{1F4CA} Confidence: ${prediction.confidence}%
-`;
-    msg += `\u{1F4C8} Composite: ${prediction.composite.toFixed(2)}
-`;
-    msg += `\u23F1 Timeframe: ${prediction.timeframe}
-
-`;
-    msg += `Signals:
-`;
-    msg += `\u2022 Technical: ${prediction.signals.technical}
-`;
-    msg += `\u2022 Sentiment: ${prediction.signals.sentiment}
-`;
-    msg += `\u2022 Derivatives: ${prediction.signals.derivatives}
-`;
-    msg += `\u2022 Trend: ${prediction.signals.trend}
-`;
-    msg += `\u2022 Macro: ${prediction.signals.macro}
-
-`;
-    if (prediction.reasoning.length > 0) {
-      msg += prediction.reasoning.join("\n") + "\n\n";
+function formatAudit(contract, overallRisk, findings) {
+  const riskEmoji = overallRisk === "low" ? "\u{1F7E2}" : overallRisk === "medium" ? "\u{1F7E1}" : overallRisk === "high" ? "\u{1F7E0}" : "\u{1F534}";
+  const lines = [
+    `*\u{1F50D} Contract Audit*`,
+    `Address: \`${escapeMarkdown(contract)}\``,
+    `${riskEmoji} Risk: *${escapeMarkdown(overallRisk.toUpperCase())}*`,
+    ""
+  ];
+  if (findings.length > 0) {
+    lines.push("*Findings:*");
+    for (const f of findings) {
+      const sevEmoji = f.severity === "critical" ? "\u{1F534}" : f.severity === "high" ? "\u{1F7E0}" : f.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      lines.push(`${sevEmoji} *${escapeMarkdown(f.title)}*: ${escapeMarkdown(f.description)}`);
     }
-    msg += prediction.disclaimer;
-    await ctx.reply(msg);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Prediction failed: ${msg}`);
+  } else {
+    lines.push("\u2705 No significant findings\\.");
   }
+  lines.push("", "_Not financial advice\\. DYOR\\._");
+  return lines.join("\n");
 }
-async function handleWallet(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const address = args2[0];
-  if (!address) {
-    await ctx.reply("Usage: /wallet <ethereum_address>\nExample: /wallet 0x...");
-    return;
-  }
-  if (!isValidAddress(address)) {
-    await ctx.reply("Invalid Ethereum address. Must start with 0x followed by 40 hex characters.");
-    return;
-  }
-  try {
-    const balance = await getWalletBalance(address);
-    await ctx.reply(
-      `\u{1F45B} Wallet Balance
-
-Address: ${address}
-Balance: ${balance} ETH
-
-Use /track <address> for full forensic analysis`
-    );
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Wallet query failed: ${msg}`);
+function formatWalletAnalysis(address, chain, balance, txCount, riskLevel, patterns) {
+  const riskEmoji = riskLevel === "low" ? "\u{1F7E2}" : riskLevel === "medium" ? "\u{1F7E1}" : riskLevel === "high" ? "\u{1F7E0}" : "\u{1F534}";
+  const lines = [
+    `*\u{1F45B} Wallet Analysis*`,
+    `Address: \`${escapeMarkdown(address)}\``,
+    `Chain: ${escapeMarkdown(chain)}`,
+    `Balance: ${escapeMarkdown(balance)} ETH`,
+    `Transactions: ${escapeMarkdown(String(txCount))}`,
+    `${riskEmoji} Risk: *${escapeMarkdown(riskLevel.toUpperCase())}*`,
+    ""
+  ];
+  if (patterns.length > 0) {
+    lines.push("*Patterns:*");
+    for (const p of patterns) {
+      lines.push(`\u2022 \\[${escapeMarkdown(p.severity)}\\] ${escapeMarkdown(p.description)}`);
+    }
+  } else {
+    lines.push("No unusual patterns detected\\.");
   }
+  return lines.join("\n");
 }
-async function handleAgentHelp(ctx) {
-  const strategies = listStrategies();
-  await ctx.reply(
-    `\u{1F916} Agent Management
-
-Commands:
-/agent_create <name> <strategy> <pairs> - Create agent
-/agent_list - List all agents
-/agent_start <name> - Start an agent
-/agent_stop <name> - Stop an agent
-/agent_status <name> - View status & decisions
-/agent_delete <name> - Delete an agent
-
-Available strategies: ${strategies.join(", ")}
+var init_market2 = __esm({
+  "src/telegram/formatters/market.ts"() {
+    "use strict";
+  }
+});
 
-Example:
-/agent_create mybot momentum BTC,ETH`
+// src/telegram/commands/index.ts
+function registerCommands(bot) {
+  bot.command(
+    "start",
+    (ctx) => ctx.reply(
+      "*Welcome to Vizzor* \u2014 AI\\-powered crypto chronovisor\\.\n\n*Commands:*\n/scan \\<address\\> \u2014 Analyze a project\n/trends \u2014 Trending tokens \\+ market movers\n/track \\<wallet\\> \u2014 Wallet forensics\n/ico \u2014 Upcoming ICOs \\& raises\n/audit \\<contract\\> \u2014 Smart contract audit\n/price \\<symbol\\> \u2014 Quick price check\n/predict \\<symbol\\> \u2014 AI prediction\n/wallet \\<address\\> \u2014 Wallet balance\n/agent \u2014 Trading agent management\n/help \u2014 Show all commands\n\n_Send any message for AI\\-powered analysis_",
+      { parse_mode: "MarkdownV2" }
+    )
+  );
+  bot.command(
+    "help",
+    (ctx) => ctx.reply(
+      "*Vizzor Commands*\n\n*Analysis:*\n/scan \\<address\\> \u2014 Analyze token/project risk\n/track \\<wallet\\> \u2014 Wallet analysis \\& forensics\n/trends \u2014 Trending tokens from DexScreener\n/ico \u2014 Upcoming ICOs \\& fundraising rounds\n/audit \\<contract\\> \u2014 Smart contract audit\n\n*Quick Commands:*\n/price \\<symbol\\> \u2014 Live price check\n/predict \\<symbol\\> \u2014 AI prediction with signals\n/wallet \\<address\\> \u2014 ETH wallet balance\n\n*Agent Management:*\n/agent\\_create \\<name\\> \\<strategy\\> \\<pairs\\>\n/agent\\_list \u2014 List all agents\n/agent\\_start \\<name\\> \u2014 Start an agent\n/agent\\_stop \\<name\\> \u2014 Stop an agent\n/agent\\_status \\<name\\> \u2014 Agent status \\& decisions\n/agent\\_delete \\<name\\> \u2014 Delete an agent\n\n_Send any message for AI\\-powered analysis_",
+      { parse_mode: "MarkdownV2" }
+    )
   );
+  bot.command("scan", handleScan2);
+  bot.command("trends", handleTrends2);
+  bot.command("track", handleTrack2);
+  bot.command("ico", handleIco);
+  bot.command("audit", handleAudit2);
+  bot.command("price", handlePrice);
+  bot.command("predict", handlePredict);
+  bot.command("wallet", handleWallet);
+  bot.command("agent", handleAgentHelp);
+  bot.command("agent_create", handleAgentCreate);
+  bot.command("agent_list", handleAgentList);
+  bot.command("agent_start", handleAgentStart);
+  bot.command("agent_stop", handleAgentStop);
+  bot.command("agent_status", handleAgentStatus);
+  bot.command("agent_delete", handleAgentDelete);
 }
-async function handleAgentCreate(ctx) {
+async function handleScan2(ctx) {
   const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const name = args2[0];
-  const strategy = args2[1] ?? "momentum";
-  const pairsStr = args2[2] ?? "BTC,ETH";
-  if (!name) {
-    await ctx.reply(
-      "Usage: /agent_create <name> <strategy> <pairs>\nExample: /agent_create mybot momentum BTC,ETH,SOL"
-    );
+  const project = args2[0];
+  if (!project) {
+    await ctx.reply("Usage: /scan <project_address>", { parse_mode: void 0 });
     return;
   }
+  await ctx.reply("\u{1F50D} Scanning project...");
   try {
-    const pairs = pairsStr.split(",").map((p) => p.trim().toUpperCase());
-    const agent = createAgent(name, strategy, pairs);
-    await ctx.reply(
-      `\u2705 Agent Created
-
-Name: ${agent.name}
-Strategy: ${agent.strategy}
-Pairs: ${agent.pairs.join(", ")}
-Interval: ${agent.interval}s
+    const adapter = getAdapter("ethereum");
+    await adapter.connect(void 0, getConfig().etherscanApiKey);
+    const analysis = await analyzeProject(project, adapter);
+    const risk = assessRisk(analysis);
+    await adapter.disconnect();
+    const riskEmoji = risk.level === "low" ? "\u{1F7E2}" : risk.level === "medium" ? "\u{1F7E1}" : risk.level === "high" ? "\u{1F7E0}" : "\u{1F534}";
+    let message = `*Project Analysis*
 
-Use /agent_start ${agent.name} to activate`
-    );
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to create agent: ${msg}`);
-  }
-}
-async function handleAgentList(ctx) {
-  const agents = listAgents();
-  if (agents.length === 0) {
-    await ctx.reply("No agents created yet. Use /agent_create to create one.");
-    return;
-  }
-  let msg = "\u{1F916} Your Agents\n\n";
-  for (const agent of agents) {
-    const state = getAgentStatus(agent.id);
-    const statusEmoji = state?.status === "running" ? "\u{1F7E2}" : state?.status === "stopped" ? "\u{1F534}" : "\u26AA";
-    msg += `${statusEmoji} ${agent.name} [${state?.status ?? "idle"}]
 `;
-    msg += `  Strategy: ${agent.strategy} | Pairs: ${agent.pairs.join(", ")}
+    message += `${riskEmoji} Risk: ${risk.score}/100 \\(${escapeMarkdown(risk.level.toUpperCase())}\\)
 `;
-    msg += `  Cycles: ${state?.cycleCount ?? 0} | Interval: ${agent.interval}s
-
+    message += `${escapeMarkdown(risk.summary)}
+`;
+    if (analysis.token) {
+      message += `
+Token: ${escapeMarkdown(analysis.token.name)} \\(${escapeMarkdown(analysis.token.symbol)}\\)`;
+    }
+    if (risk.factors.length > 0) {
+      message += "\n\n*Risk Factors*\n";
+      for (const factor of risk.factors) {
+        message += `\u2022 ${escapeMarkdown(factor)}
 `;
+      }
+    }
+    message += "\n_Not financial advice\\. DYOR\\._";
+    await ctx.reply(message, { parse_mode: "MarkdownV2" });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Error: ${msg}`);
   }
-  await ctx.reply(msg);
 }
-async function handleAgentStart(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const name = args2[0];
-  if (!name) {
-    await ctx.reply("Usage: /agent_start <name>");
-    return;
-  }
+async function handleTrends2(ctx) {
+  await ctx.reply("\u{1F4CA} Fetching trends...");
   try {
-    const agent = getAgentByName(name);
-    if (!agent) {
-      await ctx.reply(`Agent "${name}" not found. Use /agent_list to see your agents.`);
+    const trending = await fetchTrendingTokens();
+    if (trending.length === 0) {
+      await ctx.reply("No trending data available right now.");
       return;
     }
-    const state = startAgent(agent.id);
-    await ctx.reply(
-      `\u{1F7E2} Agent "${state.config.name}" started. Monitoring ${state.config.pairs.join(", ")}.`
+    const formatted = formatTrending(
+      trending.slice(0, 10).map((t) => ({
+        name: t.name,
+        symbol: t.symbol,
+        chain: t.chain,
+        priceUsd: t.priceUsd,
+        priceChange24h: t.priceChange24h,
+        volume24h: t.volume24h,
+        source: t.source
+      }))
     );
+    await ctx.reply(formatted + "\n\n_Live data from DexScreener \\& CoinGecko_", {
+      parse_mode: "MarkdownV2"
+    });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to start agent: ${msg}`);
+    await ctx.reply(`Failed to fetch trends: ${msg}`);
   }
 }
-async function handleAgentStop(ctx) {
+async function handleTrack2(ctx) {
   const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const name = args2[0];
-  if (!name) {
-    await ctx.reply("Usage: /agent_stop <name>");
+  const wallet = args2[0];
+  if (!wallet) {
+    await ctx.reply("Usage: /track <wallet_address>", { parse_mode: void 0 });
     return;
   }
+  await ctx.reply("\u{1F45B} Analyzing wallet...");
   try {
-    const agent = getAgentByName(name);
-    if (!agent) {
-      await ctx.reply(`Agent "${name}" not found.`);
-      return;
-    }
-    const state = stopAgent(agent.id);
-    await ctx.reply(`\u{1F534} Agent "${state.config.name}" stopped after ${state.cycleCount} cycles.`);
+    const adapter = getAdapter("ethereum");
+    await adapter.connect(void 0, getConfig().etherscanApiKey);
+    const analysis = await analyzeWallet(wallet, adapter);
+    await adapter.disconnect();
+    const formatted = formatWalletAnalysis(
+      analysis.address,
+      analysis.chain,
+      analysis.balance.toString(),
+      analysis.transactionCount,
+      analysis.riskLevel,
+      analysis.patterns
+    );
+    await ctx.reply(formatted, { parse_mode: "MarkdownV2" });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to stop agent: ${msg}`);
+    await ctx.reply(`Wallet analysis failed: ${msg}`);
   }
 }
-async function handleAgentStatus(ctx) {
-  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const name = args2[0];
-  if (!name) {
-    await ctx.reply("Usage: /agent_status <name>");
-    return;
-  }
-  const agent = getAgentByName(name);
-  if (!agent) {
-    await ctx.reply(`Agent "${name}" not found.`);
-    return;
-  }
-  const state = getAgentStatus(agent.id);
-  if (!state) {
-    await ctx.reply(`Agent "${name}" not found.`);
-    return;
-  }
-  const statusEmoji = state.status === "running" ? "\u{1F7E2}" : state.status === "stopped" ? "\u{1F534}" : "\u26AA";
-  let msg = `\u{1F916} Agent: ${state.config.name}
-
-`;
-  msg += `${statusEmoji} Status: ${state.status}
-`;
-  msg += `Strategy: ${state.config.strategy}
-`;
-  msg += `Pairs: ${state.config.pairs.join(", ")}
-`;
-  msg += `Interval: ${state.config.interval}s
-`;
-  msg += `Cycles: ${state.cycleCount}
-`;
-  if (state.error) msg += `Error: ${state.error}
-`;
-  const decisions = getRecentDecisions(agent.id, 5);
-  if (decisions.length > 0) {
-    msg += "\nRecent Decisions:\n";
-    for (const d of decisions) {
-      const actionEmoji = d.decision.action === "buy" ? "\u{1F7E2}" : d.decision.action === "sell" ? "\u{1F534}" : "\u26AA";
-      const time = new Date(d.timestamp).toLocaleString();
-      msg += `${actionEmoji} ${d.symbol} ${d.decision.action.toUpperCase()} (${d.decision.confidence}%) \u2014 ${time}
-`;
-      if (d.decision.reasoning.length > 0) {
-        msg += `  \u2192 ${d.decision.reasoning[0]}
-`;
+async function handleIco(ctx) {
+  await ctx.reply("\u{1F680} Fetching ICOs and raises...");
+  try {
+    const [icosResult, raisesResult] = await Promise.allSettled([
+      fetchUpcomingICOs(),
+      fetchRecentRaises(30)
+    ]);
+    const icos = icosResult.status === "fulfilled" ? icosResult.value : [];
+    const raises = raisesResult.status === "fulfilled" ? raisesResult.value : [];
+    const items = [
+      ...raises.slice(0, 10).map((r) => ({
+        name: r.name,
+        round: r.round,
+        amount: r.amount,
+        chains: r.chains,
+        leadInvestors: r.leadInvestors,
+        date: new Date(r.date * 1e3).toISOString().split("T")[0] ?? ""
+      }))
+    ];
+    const raiseNames = new Set(items.map((i) => i.name.toLowerCase()));
+    for (const ico of icos.slice(0, 5)) {
+      if (!raiseNames.has(ico.name.toLowerCase())) {
+        items.push({
+          name: ico.name,
+          round: ico.status,
+          amount: null,
+          chains: [ico.chain ?? "multi-chain"],
+          leadInvestors: [],
+          date: ico.startDate ?? ""
+        });
       }
     }
+    if (items.length === 0) {
+      await ctx.reply("No ICO or fundraising data available right now.");
+      return;
+    }
+    const formatted = formatICOs(items);
+    await ctx.reply(formatted + "\n_Data from DeFiLlama \\& Pump\\.fun_", {
+      parse_mode: "MarkdownV2"
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Failed to fetch ICOs: ${msg}`);
   }
-  await ctx.reply(msg);
 }
-async function handleAgentDelete(ctx) {
+async function handleAudit2(ctx) {
   const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
-  const name = args2[0];
-  if (!name) {
-    await ctx.reply("Usage: /agent_delete <name>");
+  const contract = args2[0];
+  if (!contract) {
+    await ctx.reply("Usage: /audit <contract_address>", { parse_mode: void 0 });
     return;
   }
+  await ctx.reply("\u{1F50D} Auditing contract...");
   try {
-    const agent = getAgentByName(name);
-    if (!agent) {
-      await ctx.reply(`Agent "${name}" not found.`);
-      return;
-    }
-    deleteAgent(agent.id);
-    await ctx.reply(`\u{1F5D1} Agent "${name}" deleted.`);
+    const adapter = getAdapter("ethereum");
+    await adapter.connect(void 0, getConfig().etherscanApiKey);
+    const result = await auditContract(contract, adapter);
+    await adapter.disconnect();
+    const formatted = formatAudit(
+      contract,
+      result.overallRisk,
+      result.findings.map((f) => ({
+        severity: f.severity,
+        title: f.title,
+        description: f.description
+      }))
+    );
+    await ctx.reply(formatted, { parse_mode: "MarkdownV2" });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    await ctx.reply(`Failed to delete agent: ${msg}`);
+    await ctx.reply(`Audit failed: ${msg}`);
   }
 }
-var init_commands2 = __esm({
-  "src/telegram/commands/index.ts"() {
-    "use strict";
-    init_registry();
-    init_loader();
-    init_project_analyzer();
-    init_risk_scorer();
-    init_wallet_analyzer();
-    init_contract_auditor();
-    init_market();
-    init_ico_tracker();
-    init_defillama();
-    init_binance();
-    init_predictor();
-    init_agent();
-    init_market2();
-  }
-});
-
-// src/telegram/middleware/rate-limit.ts
-async function rateLimitMiddleware(ctx, next) {
-  const userId = ctx.from?.id;
-  if (!userId) {
-    await next();
-    return;
-  }
-  const now = Date.now();
-  const entry = userLimits2.get(userId);
-  if (!entry || now >= entry.resetAt) {
-    userLimits2.set(userId, { count: 1, resetAt: now + WINDOW_MS2 });
-    await next();
-    return;
-  }
-  if (entry.count >= MAX_REQUESTS2) {
-    await ctx.reply("Rate limited. Please wait a moment before sending more commands.");
+async function handlePrice(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const symbol = args2[0]?.toUpperCase();
+  if (!symbol) {
+    await ctx.reply("Usage: /price <symbol>\nExample: /price BTC");
     return;
   }
-  entry.count++;
-  await next();
-}
-function startRateLimitCleanup2(intervalMs = 3e5) {
-  return setInterval(() => {
-    const now = Date.now();
-    for (const [userId, entry] of userLimits2) {
-      if (now >= entry.resetAt) {
-        userLimits2.delete(userId);
-      }
-    }
-  }, intervalMs);
-}
-var userLimits2, MAX_REQUESTS2, WINDOW_MS2;
-var init_rate_limit2 = __esm({
-  "src/telegram/middleware/rate-limit.ts"() {
-    "use strict";
-    userLimits2 = /* @__PURE__ */ new Map();
-    MAX_REQUESTS2 = 10;
-    WINDOW_MS2 = 6e4;
-  }
-});
-
-// src/telegram/bot.ts
-var bot_exports2 = {};
-__export(bot_exports2, {
-  startTelegramBot: () => startTelegramBot
-});
-import { Bot } from "grammy";
-async function startTelegramBot() {
-  const config2 = loadConfig();
-  const token = config2.telegramToken;
-  if (!token) {
-    throw new Error("Telegram token not configured. Run: vizzor config set telegramToken <token>");
-  }
-  setConfig(config2);
-  setToolHandler(handleTool);
-  const bot = new Bot(token);
-  bot.use(rateLimitMiddleware);
-  registerCommands(bot);
-  bot.on("message:text", async (ctx) => {
-    const text = ctx.message.text;
-    if (text.startsWith("/")) return;
-    await ctx.reply("\u{1F52E} Analyzing...");
-    try {
-      const response = await analyze(buildChatSystemPrompt(), text, VIZZOR_TOOLS);
-      const chunks = splitMessage(response, 4e3);
-      for (const chunk of chunks) {
-        await ctx.reply(chunk);
-      }
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      await ctx.reply(`Analysis failed: ${msg}`);
-    }
-  });
-  bot.catch((err) => {
-    logger2.error({ err: err.message }, "Telegram bot error");
-  });
-  const cleanupInterval = startRateLimitCleanup2();
-  logger2.info("Telegram bot starting...");
-  await bot.start({
-    onStart: (botInfo) => {
-      logger2.info(`Telegram bot started as @${botInfo.username}`);
-    }
-  });
-  clearInterval(cleanupInterval);
-}
-var logger2;
-var init_bot2 = __esm({
-  "src/telegram/bot.ts"() {
-    "use strict";
-    init_loader();
-    init_client();
-    init_tool_handler();
-    init_tools();
-    init_chat();
-    init_message_split();
-    init_commands2();
-    init_rate_limit2();
-    init_logger();
-    logger2 = createLogger("telegram-bot");
-  }
-});
+  try {
+    const ticker = await fetchTickerPrice(symbol);
+    const changeEmoji = ticker.change24h >= 0 ? "\u{1F7E2}" : "\u{1F534}";
+    const changeSign = ticker.change24h >= 0 ? "+" : "";
+    await ctx.reply(
+      `\u{1F4B0} ${ticker.symbol}
+Price: $${ticker.price.toLocaleString()}
+${changeEmoji} 24h: ${changeSign}${ticker.change24h.toFixed(2)}%
 
-// src/cli/commands/bot.ts
-var bot_exports3 = {};
-__export(bot_exports3, {
-  handleBotStart: () => handleBotStart,
-  handleBotValidate: () => handleBotValidate
-});
-import chalk7 from "chalk";
-async function handleBotStart(options) {
-  const config2 = getConfig();
-  const startDiscord = options.discord || options.all;
-  const startTelegram = options.telegram || options.all;
-  if (!startDiscord && !startTelegram) {
-    console.log(chalk7.yellow("Specify which bot to start:"));
-    console.log("  --discord   Start Discord bot");
-    console.log("  --telegram  Start Telegram bot");
-    console.log("  --all       Start all bots");
-    return;
-  }
-  const promises = [];
-  if (startDiscord) {
-    requireKey("DISCORD_TOKEN", config2.discordToken);
-    console.log(chalk7.blue("Starting Discord bot..."));
-    const { startDiscordBot: startDiscordBot2 } = await Promise.resolve().then(() => (init_bot(), bot_exports));
-    promises.push(startDiscordBot2());
-  }
-  if (startTelegram) {
-    requireKey("TELEGRAM_BOT_TOKEN", config2.telegramToken);
-    console.log(chalk7.blue("Starting Telegram bot..."));
-    const { startTelegramBot: startTelegramBot2 } = await Promise.resolve().then(() => (init_bot2(), bot_exports2));
-    promises.push(startTelegramBot2());
-  }
-  const shutdown = () => {
-    console.log(chalk7.dim("\nShutting down bots..."));
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  await Promise.all(promises);
-}
-function handleBotValidate() {
-  const config2 = getConfig();
-  console.log(chalk7.bold("\nVizzor Bot Configuration Check\n"));
-  const checks = [
-    { label: "Anthropic API Key", isSet: hasKey(config2.anthropicApiKey), required: true },
-    { label: "Etherscan API Key", isSet: hasKey(config2.etherscanApiKey), required: true },
-    { label: "Discord Token", isSet: hasKey(config2.discordToken), required: false },
-    { label: "Discord Guild ID", isSet: hasKey(config2.discordGuildId), required: false },
-    { label: "Telegram Token", isSet: hasKey(config2.telegramToken), required: false },
-    { label: "CryptoPanic Key", isSet: hasKey(config2.cryptopanicApiKey), required: false }
-  ];
-  let allRequired = true;
-  for (const check of checks) {
-    const status = check.isSet ? chalk7.green("OK") : check.required ? chalk7.red("MISSING") : chalk7.yellow("NOT SET");
-    console.log(`  ${status.padEnd(18)} ${check.label}`);
-    if (check.required && !check.isSet) allRequired = false;
-  }
-  console.log();
-  if (hasKey(config2.discordToken)) {
-    console.log(chalk7.green("  Discord bot:  Ready to start"));
-  } else {
-    console.log(chalk7.yellow("  Discord bot:  Set discordToken to enable"));
-    console.log(chalk7.dim("                vizzor config set discordToken <token>"));
+Live from Binance`
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Price check failed: ${msg}`);
   }
-  if (hasKey(config2.telegramToken)) {
-    console.log(chalk7.green("  Telegram bot: Ready to start"));
-  } else {
-    console.log(chalk7.yellow("  Telegram bot: Set telegramToken to enable"));
-    console.log(chalk7.dim("                vizzor config set telegramToken <token>"));
+}
+async function handlePredict(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const symbol = args2[0]?.toUpperCase();
+  if (!symbol) {
+    await ctx.reply("Usage: /predict <symbol>\nExample: /predict ETH");
+    return;
   }
-  console.log();
-  if (!allRequired) {
-    console.log(chalk7.red("Required keys are missing. Run: vizzor config set <key> <value>"));
-  } else if (hasKey(config2.discordToken) && hasKey(config2.telegramToken)) {
-    console.log(chalk7.green("All bots ready. Run: vizzor bot start --all"));
-  } else if (hasKey(config2.discordToken) || hasKey(config2.telegramToken)) {
-    const which = hasKey(config2.discordToken) ? "--discord" : "--telegram";
-    console.log(chalk7.green(`Bot ready. Run: vizzor bot start ${which}`));
+  await ctx.reply(`\u{1F52E} Generating prediction for ${symbol}...`);
+  try {
+    const prediction = await generatePrediction(symbol);
+    const dirEmoji = prediction.direction === "up" ? "\u{1F7E2}" : prediction.direction === "down" ? "\u{1F534}" : "\u26AA";
+    let msg = `\u{1F52E} ${prediction.symbol} Prediction
+
+`;
+    msg += `${dirEmoji} Direction: ${prediction.direction.toUpperCase()}
+`;
+    msg += `\u{1F4CA} Confidence: ${prediction.confidence}%
+`;
+    msg += `\u{1F4C8} Composite: ${prediction.composite.toFixed(2)}
+`;
+    msg += `\u23F1 Timeframe: ${prediction.timeframe}
+
+`;
+    msg += `Signals:
+`;
+    msg += `\u2022 Technical: ${prediction.signals.technical}
+`;
+    msg += `\u2022 Sentiment: ${prediction.signals.sentiment}
+`;
+    msg += `\u2022 Derivatives: ${prediction.signals.derivatives}
+`;
+    msg += `\u2022 Trend: ${prediction.signals.trend}
+`;
+    msg += `\u2022 Macro: ${prediction.signals.macro}
+
+`;
+    if (prediction.reasoning.length > 0) {
+      msg += prediction.reasoning.join("\n") + "\n\n";
+    }
+    msg += prediction.disclaimer;
+    await ctx.reply(msg);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Prediction failed: ${msg}`);
   }
 }
-var init_bot3 = __esm({
-  "src/cli/commands/bot.ts"() {
-    "use strict";
-    init_loader();
-    init_keys();
+async function handleWallet(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const address = args2[0];
+  if (!address) {
+    await ctx.reply("Usage: /wallet <ethereum_address>\nExample: /wallet 0x...");
+    return;
   }
-});
+  if (!isValidAddress(address)) {
+    await ctx.reply("Invalid Ethereum address. Must start with 0x followed by 40 hex characters.");
+    return;
+  }
+  try {
+    const balance = await getWalletBalance(address);
+    await ctx.reply(
+      `\u{1F45B} Wallet Balance
 
-// src/data/sqlite-store.ts
-function ensureAgentTables2() {
-  const db2 = getDb();
-  db2.exec(`
-    CREATE TABLE IF NOT EXISTS agents (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      strategy TEXT NOT NULL,
-      pairs TEXT NOT NULL,
-      interval_seconds INTEGER NOT NULL DEFAULT 60,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-  db2.exec(`
-    CREATE TABLE IF NOT EXISTS agent_decisions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      agent_id TEXT NOT NULL,
-      symbol TEXT NOT NULL,
-      action TEXT NOT NULL,
-      confidence INTEGER NOT NULL,
-      reasoning TEXT NOT NULL,
-      signals TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (agent_id) REFERENCES agents(id)
-    )
-  `);
+Address: ${address}
+Balance: ${balance} ETH
+
+Use /track <address> for full forensic analysis`
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Wallet query failed: ${msg}`);
+  }
 }
-function rowToConfig(row) {
-  return {
-    id: row.id,
-    name: row.name,
-    strategy: row.strategy,
-    pairs: JSON.parse(row.pairs),
-    interval: row.interval_seconds,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
+async function handleAgentHelp(ctx) {
+  const strategies = listStrategies();
+  await ctx.reply(
+    `\u{1F916} Agent Management
+
+Commands:
+/agent_create <name> <strategy> <pairs> - Create agent
+/agent_list - List all agents
+/agent_start <name> - Start an agent
+/agent_stop <name> - Stop an agent
+/agent_status <name> - View status & decisions
+/agent_delete <name> - Delete an agent
+
+Available strategies: ${strategies.join(", ")}
+
+Example:
+/agent_create mybot momentum BTC,ETH`
+  );
 }
-var SqliteStore;
-var init_sqlite_store = __esm({
-  "src/data/sqlite-store.ts"() {
-    "use strict";
-    init_cache();
-    SqliteStore = class {
-      // ---- Cache ---------------------------------------------------------------
-      async getCached(key) {
-        return getCached(key);
-      }
-      async setCache(key, value, ttlSeconds) {
-        setCache(key, value, ttlSeconds);
-      }
-      // ---- Agents --------------------------------------------------------------
-      async createAgent(config2) {
-        ensureAgentTables2();
-        getDb().prepare(
-          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
-        ).run(
-          config2.id,
-          config2.name,
-          config2.strategy,
-          JSON.stringify(config2.pairs),
-          config2.interval,
-          config2.createdAt,
-          config2.updatedAt
-        );
-        return config2;
-      }
-      async listAgents() {
-        ensureAgentTables2();
-        const rows = getDb().prepare("SELECT * FROM agents ORDER BY created_at DESC").all();
-        return rows.map(rowToConfig);
-      }
-      async getAgentById(id) {
-        ensureAgentTables2();
-        const row = getDb().prepare("SELECT * FROM agents WHERE id = ?").get(id);
-        return row ? rowToConfig(row) : null;
-      }
-      async getAgentByName(name) {
-        ensureAgentTables2();
-        const row = getDb().prepare("SELECT * FROM agents WHERE name = ?").get(name);
-        return row ? rowToConfig(row) : null;
-      }
-      async deleteAgent(id) {
-        ensureAgentTables2();
-        const result = getDb().prepare("DELETE FROM agents WHERE id = ?").run(id);
-        getDb().prepare("DELETE FROM agent_decisions WHERE agent_id = ?").run(id);
-        return result.changes > 0;
-      }
-      async logDecision(result) {
-        ensureAgentTables2();
-        getDb().prepare(
-          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
-        ).run(
-          result.agentId,
-          result.symbol,
-          result.decision.action,
-          result.decision.confidence,
-          JSON.stringify(result.decision.reasoning),
-          JSON.stringify(result.signals),
-          result.timestamp
-        );
-      }
-      async getDecisions(agentId, limit) {
-        ensureAgentTables2();
-        const rows = getDb().prepare("SELECT * FROM agent_decisions WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?").all(agentId, limit);
-        return rows.map((r) => ({
-          agentId: r.agent_id,
-          symbol: r.symbol,
-          timestamp: r.created_at,
-          signals: JSON.parse(r.signals),
-          decision: {
-            action: r.action,
-            confidence: r.confidence,
-            reasoning: JSON.parse(r.reasoning)
-          }
-        }));
-      }
-      // ---- Time-series (no-op for SQLite) --------------------------------------
-      async insertOHLCV(_records) {
-      }
-      async queryOHLCV(_symbol, _timeframe, _from, _to) {
-        return [];
-      }
-      // ---- Predictions (no-op for SQLite) --------------------------------------
-      async logPrediction(_prediction) {
-      }
-      async getPredictionAccuracy(_model, _days) {
-        return {
-          model: _model,
-          totalPredictions: 0,
-          correctPredictions: 0,
-          accuracy: 0,
-          byDirection: {
-            up: { total: 0, correct: 0, accuracy: 0 },
-            down: { total: 0, correct: 0, accuracy: 0 },
-            sideways: { total: 0, correct: 0, accuracy: 0 }
-          },
-          period: `${_days}d`
-        };
-      }
-      // ---- Lifecycle -----------------------------------------------------------
-      async close() {
-      }
-    };
+async function handleAgentCreate(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const name = args2[0];
+  const strategy = args2[1] ?? "momentum";
+  const pairsStr = args2[2] ?? "BTC,ETH";
+  if (!name) {
+    await ctx.reply(
+      "Usage: /agent_create <name> <strategy> <pairs>\nExample: /agent_create mybot momentum BTC,ETH,SOL"
+    );
+    return;
   }
-});
+  try {
+    const pairs = pairsStr.split(",").map((p) => p.trim().toUpperCase());
+    const agent = createAgent(name, strategy, pairs);
+    await ctx.reply(
+      `\u2705 Agent Created
 
-// src/data/postgres-store.ts
-var postgres_store_exports = {};
-__export(postgres_store_exports, {
-  PostgresStore: () => PostgresStore
-});
-import pg from "pg";
-import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import { fileURLToPath } from "url";
-var __filename, __dirname, PostgresStore;
-var init_postgres_store = __esm({
-  "src/data/postgres-store.ts"() {
-    "use strict";
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = dirname(__filename);
-    PostgresStore = class {
-      pool;
-      initialized = false;
-      constructor(connectionUrl) {
-        this.pool = new pg.Pool({ connectionString: connectionUrl, max: 10 });
-      }
-      async init() {
-        if (this.initialized) return;
-        const migrationPath = resolve2(__dirname, "migrations", "001-init.sql");
-        const sql = readFileSync2(migrationPath, "utf-8");
-        await this.pool.query(sql);
-        this.initialized = true;
-      }
-      async query(text, params) {
-        await this.init();
-        return this.pool.query(text, params);
-      }
-      // ---- Cache ---------------------------------------------------------------
-      async getCached(key) {
-        const now = Math.floor(Date.now() / 1e3);
-        const { rows } = await this.query(
-          "SELECT value FROM cache WHERE key = $1 AND expires_at > $2",
-          [key, now]
-        );
-        if (rows.length === 0) return null;
-        return rows[0].value;
-      }
-      async setCache(key, value, ttlSeconds) {
-        const now = Math.floor(Date.now() / 1e3);
-        const expiresAt = now + ttlSeconds;
-        await this.query(
-          `INSERT INTO cache (key, value, expires_at, created_at)
-       VALUES ($1, $2, $3, $4)
-       ON CONFLICT (key) DO UPDATE SET value = $2, expires_at = $3`,
-          [key, JSON.stringify(value), expiresAt, now]
-        );
-      }
-      // ---- Agents --------------------------------------------------------------
-      async createAgent(config2) {
-        await this.query(
-          `INSERT INTO agents (id, name, strategy, pairs, interval_seconds, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
-          [
-            config2.id,
-            config2.name,
-            config2.strategy,
-            JSON.stringify(config2.pairs),
-            config2.interval,
-            config2.createdAt,
-            config2.updatedAt
-          ]
-        );
-        return config2;
-      }
-      async listAgents() {
-        const { rows } = await this.query("SELECT * FROM agents ORDER BY created_at DESC");
-        return rows.map((r) => ({
-          id: r.id,
-          name: r.name,
-          strategy: r.strategy,
-          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
-          interval: r.interval_seconds,
-          createdAt: Number(r.created_at),
-          updatedAt: Number(r.updated_at)
-        }));
-      }
-      async getAgentById(id) {
-        const { rows } = await this.query("SELECT * FROM agents WHERE id = $1", [id]);
-        if (rows.length === 0) return null;
-        const r = rows[0];
-        return {
-          id: r.id,
-          name: r.name,
-          strategy: r.strategy,
-          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
-          interval: r.interval_seconds,
-          createdAt: Number(r.created_at),
-          updatedAt: Number(r.updated_at)
-        };
-      }
-      async getAgentByName(name) {
-        const { rows } = await this.query("SELECT * FROM agents WHERE name = $1", [name]);
-        if (rows.length === 0) return null;
-        const r = rows[0];
-        return {
-          id: r.id,
-          name: r.name,
-          strategy: r.strategy,
-          pairs: typeof r.pairs === "string" ? JSON.parse(r.pairs) : r.pairs,
-          interval: r.interval_seconds,
-          createdAt: Number(r.created_at),
-          updatedAt: Number(r.updated_at)
-        };
-      }
-      async deleteAgent(id) {
-        const result = await this.query("DELETE FROM agents WHERE id = $1", [id]);
-        return (result.rowCount ?? 0) > 0;
-      }
-      async logDecision(result) {
-        await this.query(
-          `INSERT INTO agent_decisions (agent_id, symbol, action, confidence, reasoning, signals, created_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
-          [
-            result.agentId,
-            result.symbol,
-            result.decision.action,
-            result.decision.confidence,
-            JSON.stringify(result.decision.reasoning),
-            JSON.stringify(result.signals),
-            result.timestamp
-          ]
-        );
-      }
-      async getDecisions(agentId, limit) {
-        const { rows } = await this.query("SELECT * FROM agent_decisions WHERE agent_id = $1 ORDER BY created_at DESC LIMIT $2", [
-          agentId,
-          limit
-        ]);
-        return rows.map((r) => ({
-          agentId: r.agent_id,
-          symbol: r.symbol,
-          timestamp: Number(r.created_at),
-          signals: typeof r.signals === "string" ? JSON.parse(r.signals) : r.signals,
-          decision: {
-            action: r.action,
-            confidence: r.confidence,
-            reasoning: typeof r.reasoning === "string" ? JSON.parse(r.reasoning) : r.reasoning
-          }
-        }));
-      }
-      // ---- Time-series ---------------------------------------------------------
-      async insertOHLCV(records) {
-        if (records.length === 0) return;
-        const values = [];
-        const placeholders = [];
-        for (let i = 0; i < records.length; i++) {
-          const r = records[i];
-          const offset = i * 9;
-          placeholders.push(
-            `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`
-          );
-          values.push(
-            new Date(r.time).toISOString(),
-            r.symbol,
-            r.timeframe,
-            r.open,
-            r.high,
-            r.low,
-            r.close,
-            r.volume,
-            r.trades
-          );
-        }
-        await this.query(
-          `INSERT INTO ohlcv (time, symbol, timeframe, open, high, low, close, volume, trades)
-       VALUES ${placeholders.join(", ")}
-       ON CONFLICT (symbol, timeframe, time) DO UPDATE
-       SET open = EXCLUDED.open, high = EXCLUDED.high, low = EXCLUDED.low,
-           close = EXCLUDED.close, volume = EXCLUDED.volume, trades = EXCLUDED.trades`,
-          values
-        );
-      }
-      async queryOHLCV(symbol, timeframe, from, to) {
-        const { rows } = await this.query(
-          `SELECT * FROM ohlcv
-       WHERE symbol = $1 AND timeframe = $2 AND time >= $3 AND time <= $4
-       ORDER BY time ASC`,
-          [symbol, timeframe, new Date(from).toISOString(), new Date(to).toISOString()]
-        );
-        return rows.map((r) => ({
-          time: new Date(r.time).getTime(),
-          symbol: r.symbol,
-          timeframe: r.timeframe,
-          open: r.open,
-          high: r.high,
-          low: r.low,
-          close: r.close,
-          volume: r.volume,
-          trades: r.trades
-        }));
-      }
-      // ---- Predictions ---------------------------------------------------------
-      async logPrediction(prediction) {
-        await this.query(
-          `INSERT INTO predictions (symbol, model, direction, probability, horizon, features, predicted_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
-          [
-            prediction.symbol,
-            prediction.model,
-            prediction.direction,
-            prediction.probability,
-            prediction.horizon,
-            JSON.stringify(prediction.features),
-            new Date(prediction.predictedAt).toISOString()
-          ]
-        );
+Name: ${agent.name}
+Strategy: ${agent.strategy}
+Pairs: ${agent.pairs.join(", ")}
+Interval: ${agent.interval}s
+
+Use /agent_start ${agent.name} to activate`
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Failed to create agent: ${msg}`);
+  }
+}
+async function handleAgentList(ctx) {
+  const agents = listAgents();
+  if (agents.length === 0) {
+    await ctx.reply("No agents created yet. Use /agent_create to create one.");
+    return;
+  }
+  let msg = "\u{1F916} Your Agents\n\n";
+  for (const agent of agents) {
+    const state = getAgentStatus(agent.id);
+    const statusEmoji = state?.status === "running" ? "\u{1F7E2}" : state?.status === "stopped" ? "\u{1F534}" : "\u26AA";
+    msg += `${statusEmoji} ${agent.name} [${state?.status ?? "idle"}]
+`;
+    msg += `  Strategy: ${agent.strategy} | Pairs: ${agent.pairs.join(", ")}
+`;
+    msg += `  Cycles: ${state?.cycleCount ?? 0} | Interval: ${agent.interval}s
+
+`;
+  }
+  await ctx.reply(msg);
+}
+async function handleAgentStart(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const name = args2[0];
+  if (!name) {
+    await ctx.reply("Usage: /agent_start <name>");
+    return;
+  }
+  try {
+    const agent = getAgentByName(name);
+    if (!agent) {
+      await ctx.reply(`Agent "${name}" not found. Use /agent_list to see your agents.`);
+      return;
+    }
+    const state = startAgent(agent.id);
+    await ctx.reply(
+      `\u{1F7E2} Agent "${state.config.name}" started. Monitoring ${state.config.pairs.join(", ")}.`
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Failed to start agent: ${msg}`);
+  }
+}
+async function handleAgentStop(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const name = args2[0];
+  if (!name) {
+    await ctx.reply("Usage: /agent_stop <name>");
+    return;
+  }
+  try {
+    const agent = getAgentByName(name);
+    if (!agent) {
+      await ctx.reply(`Agent "${name}" not found.`);
+      return;
+    }
+    const state = stopAgent(agent.id);
+    await ctx.reply(`\u{1F534} Agent "${state.config.name}" stopped after ${state.cycleCount} cycles.`);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Failed to stop agent: ${msg}`);
+  }
+}
+async function handleAgentStatus(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const name = args2[0];
+  if (!name) {
+    await ctx.reply("Usage: /agent_status <name>");
+    return;
+  }
+  const agent = getAgentByName(name);
+  if (!agent) {
+    await ctx.reply(`Agent "${name}" not found.`);
+    return;
+  }
+  const state = getAgentStatus(agent.id);
+  if (!state) {
+    await ctx.reply(`Agent "${name}" not found.`);
+    return;
+  }
+  const statusEmoji = state.status === "running" ? "\u{1F7E2}" : state.status === "stopped" ? "\u{1F534}" : "\u26AA";
+  let msg = `\u{1F916} Agent: ${state.config.name}
+
+`;
+  msg += `${statusEmoji} Status: ${state.status}
+`;
+  msg += `Strategy: ${state.config.strategy}
+`;
+  msg += `Pairs: ${state.config.pairs.join(", ")}
+`;
+  msg += `Interval: ${state.config.interval}s
+`;
+  msg += `Cycles: ${state.cycleCount}
+`;
+  if (state.error) msg += `Error: ${state.error}
+`;
+  const decisions = getRecentDecisions(agent.id, 5);
+  if (decisions.length > 0) {
+    msg += "\nRecent Decisions:\n";
+    for (const d of decisions) {
+      const actionEmoji = d.decision.action === "buy" ? "\u{1F7E2}" : d.decision.action === "sell" ? "\u{1F534}" : "\u26AA";
+      const time = new Date(d.timestamp).toLocaleString();
+      msg += `${actionEmoji} ${d.symbol} ${d.decision.action.toUpperCase()} (${d.decision.confidence}%) \u2014 ${time}
+`;
+      if (d.decision.reasoning.length > 0) {
+        msg += `  \u2192 ${d.decision.reasoning[0]}
+`;
       }
-      async getPredictionAccuracy(model, days) {
-        const since = new Date(Date.now() - days * 864e5).toISOString();
-        const { rows: totals } = await this.query(
-          `SELECT direction,
-              COUNT(*)::text AS total,
-              COUNT(*) FILTER (WHERE was_correct = true)::text AS correct
-       FROM predictions
-       WHERE model = $1 AND predicted_at >= $2 AND was_correct IS NOT NULL
-       GROUP BY direction`,
-          [model, since]
-        );
-        const byDir = {
-          up: { total: 0, correct: 0, accuracy: 0 },
-          down: { total: 0, correct: 0, accuracy: 0 },
-          sideways: { total: 0, correct: 0, accuracy: 0 }
-        };
-        let totalAll = 0;
-        let correctAll = 0;
-        for (const row of totals) {
-          const t = parseInt(row.total, 10);
-          const c = parseInt(row.correct, 10);
-          totalAll += t;
-          correctAll += c;
-          const dir = row.direction;
-          if (byDir[dir]) {
-            byDir[dir] = { total: t, correct: c, accuracy: t > 0 ? c / t : 0 };
-          }
-        }
-        return {
-          model,
-          totalPredictions: totalAll,
-          correctPredictions: correctAll,
-          accuracy: totalAll > 0 ? correctAll / totalAll : 0,
-          byDirection: byDir,
-          period: `${days}d`
-        };
+    }
+  }
+  await ctx.reply(msg);
+}
+async function handleAgentDelete(ctx) {
+  const args2 = ctx.message?.text?.split(" ").slice(1) ?? [];
+  const name = args2[0];
+  if (!name) {
+    await ctx.reply("Usage: /agent_delete <name>");
+    return;
+  }
+  try {
+    const agent = getAgentByName(name);
+    if (!agent) {
+      await ctx.reply(`Agent "${name}" not found.`);
+      return;
+    }
+    deleteAgent(agent.id);
+    await ctx.reply(`\u{1F5D1} Agent "${name}" deleted.`);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    await ctx.reply(`Failed to delete agent: ${msg}`);
+  }
+}
+var init_commands2 = __esm({
+  "src/telegram/commands/index.ts"() {
+    "use strict";
+    init_registry();
+    init_loader();
+    init_project_analyzer();
+    init_risk_scorer();
+    init_wallet_analyzer();
+    init_contract_auditor();
+    init_market();
+    init_ico_tracker();
+    init_defillama();
+    init_binance();
+    init_predictor();
+    init_agent();
+    init_market2();
+  }
+});
+
+// src/telegram/middleware/rate-limit.ts
+async function rateLimitMiddleware(ctx, next) {
+  const userId = ctx.from?.id;
+  if (!userId) {
+    await next();
+    return;
+  }
+  const now = Date.now();
+  const entry = userLimits2.get(userId);
+  if (!entry || now >= entry.resetAt) {
+    userLimits2.set(userId, { count: 1, resetAt: now + WINDOW_MS2 });
+    await next();
+    return;
+  }
+  if (entry.count >= MAX_REQUESTS2) {
+    await ctx.reply("Rate limited. Please wait a moment before sending more commands.");
+    return;
+  }
+  entry.count++;
+  await next();
+}
+function startRateLimitCleanup2(intervalMs = 3e5) {
+  return setInterval(() => {
+    const now = Date.now();
+    for (const [userId, entry] of userLimits2) {
+      if (now >= entry.resetAt) {
+        userLimits2.delete(userId);
       }
-      // ---- Lifecycle -----------------------------------------------------------
-      async close() {
-        await this.pool.end();
+    }
+  }, intervalMs);
+}
+var userLimits2, MAX_REQUESTS2, WINDOW_MS2;
+var init_rate_limit2 = __esm({
+  "src/telegram/middleware/rate-limit.ts"() {
+    "use strict";
+    userLimits2 = /* @__PURE__ */ new Map();
+    MAX_REQUESTS2 = 10;
+    WINDOW_MS2 = 6e4;
+  }
+});
+
+// src/telegram/bot.ts
+var bot_exports2 = {};
+__export(bot_exports2, {
+  startTelegramBot: () => startTelegramBot
+});
+import { Bot } from "grammy";
+async function startTelegramBot() {
+  const config2 = loadConfig();
+  const token = config2.telegramToken;
+  if (!token) {
+    throw new Error("Telegram token not configured. Run: vizzor config set telegramToken <token>");
+  }
+  setConfig(config2);
+  setToolHandler(handleTool);
+  const bot = new Bot(token);
+  bot.use(rateLimitMiddleware);
+  registerCommands(bot);
+  bot.on("message:text", async (ctx) => {
+    const text = ctx.message.text;
+    if (text.startsWith("/")) return;
+    await ctx.reply("\u{1F52E} Analyzing...");
+    try {
+      const response = await analyze(buildChatSystemPrompt(), text, VIZZOR_TOOLS);
+      const chunks = splitMessage(response, 4e3);
+      for (const chunk of chunks) {
+        await ctx.reply(chunk);
       }
-    };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      await ctx.reply(`Analysis failed: ${msg}`);
+    }
+  });
+  bot.catch((err) => {
+    logger2.error({ err: err.message }, "Telegram bot error");
+  });
+  const cleanupInterval = startRateLimitCleanup2();
+  logger2.info("Telegram bot starting...");
+  await bot.start({
+    onStart: (botInfo) => {
+      logger2.info(`Telegram bot started as @${botInfo.username}`);
+    }
+  });
+  clearInterval(cleanupInterval);
+}
+var logger2;
+var init_bot2 = __esm({
+  "src/telegram/bot.ts"() {
+    "use strict";
+    init_loader();
+    init_client2();
+    init_tool_handler();
+    init_tools();
+    init_chat();
+    init_message_split();
+    init_commands2();
+    init_rate_limit2();
+    init_logger();
+    logger2 = createLogger("telegram-bot");
   }
 });
 
-// src/data/store-factory.ts
-async function getStore(config2) {
-  if (instance) return instance;
-  if (config2.database?.type === "postgres" && config2.database.url) {
-    const { PostgresStore: PostgresStore2 } = await Promise.resolve().then(() => (init_postgres_store(), postgres_store_exports));
-    instance = new PostgresStore2(config2.database.url);
+// src/cli/commands/bot.ts
+var bot_exports3 = {};
+__export(bot_exports3, {
+  handleBotStart: () => handleBotStart,
+  handleBotValidate: () => handleBotValidate
+});
+import chalk7 from "chalk";
+async function handleBotStart(options) {
+  const config2 = getConfig();
+  const startDiscord = options.discord || options.all;
+  const startTelegram = options.telegram || options.all;
+  if (!startDiscord && !startTelegram) {
+    console.log(chalk7.yellow("Specify which bot to start:"));
+    console.log("  --discord   Start Discord bot");
+    console.log("  --telegram  Start Telegram bot");
+    console.log("  --all       Start all bots");
+    return;
+  }
+  const promises = [];
+  if (startDiscord) {
+    requireKey("DISCORD_TOKEN", config2.discordToken);
+    console.log(chalk7.blue("Starting Discord bot..."));
+    const { startDiscordBot: startDiscordBot2 } = await Promise.resolve().then(() => (init_bot(), bot_exports));
+    promises.push(startDiscordBot2());
+  }
+  if (startTelegram) {
+    requireKey("TELEGRAM_BOT_TOKEN", config2.telegramToken);
+    console.log(chalk7.blue("Starting Telegram bot..."));
+    const { startTelegramBot: startTelegramBot2 } = await Promise.resolve().then(() => (init_bot2(), bot_exports2));
+    promises.push(startTelegramBot2());
+  }
+  const shutdown = () => {
+    console.log(chalk7.dim("\nShutting down bots..."));
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await Promise.all(promises);
+}
+function handleBotValidate() {
+  const config2 = getConfig();
+  console.log(chalk7.bold("\nVizzor Bot Configuration Check\n"));
+  const checks = [
+    { label: "Anthropic API Key", isSet: hasKey(config2.anthropicApiKey), required: true },
+    { label: "Etherscan API Key", isSet: hasKey(config2.etherscanApiKey), required: true },
+    { label: "Discord Token", isSet: hasKey(config2.discordToken), required: false },
+    { label: "Discord Guild ID", isSet: hasKey(config2.discordGuildId), required: false },
+    { label: "Telegram Token", isSet: hasKey(config2.telegramToken), required: false },
+    { label: "CryptoPanic Key", isSet: hasKey(config2.cryptopanicApiKey), required: false }
+  ];
+  let allRequired = true;
+  for (const check of checks) {
+    const status = check.isSet ? chalk7.green("OK") : check.required ? chalk7.red("MISSING") : chalk7.yellow("NOT SET");
+    console.log(`  ${status.padEnd(18)} ${check.label}`);
+    if (check.required && !check.isSet) allRequired = false;
+  }
+  console.log();
+  if (hasKey(config2.discordToken)) {
+    console.log(chalk7.green("  Discord bot:  Ready to start"));
   } else {
-    instance = new SqliteStore();
+    console.log(chalk7.yellow("  Discord bot:  Set discordToken to enable"));
+    console.log(chalk7.dim("                vizzor config set discordToken <token>"));
+  }
+  if (hasKey(config2.telegramToken)) {
+    console.log(chalk7.green("  Telegram bot: Ready to start"));
+  } else {
+    console.log(chalk7.yellow("  Telegram bot: Set telegramToken to enable"));
+    console.log(chalk7.dim("                vizzor config set telegramToken <token>"));
+  }
+  console.log();
+  if (!allRequired) {
+    console.log(chalk7.red("Required keys are missing. Run: vizzor config set <key> <value>"));
+  } else if (hasKey(config2.discordToken) && hasKey(config2.telegramToken)) {
+    console.log(chalk7.green("All bots ready. Run: vizzor bot start --all"));
+  } else if (hasKey(config2.discordToken) || hasKey(config2.telegramToken)) {
+    const which = hasKey(config2.discordToken) ? "--discord" : "--telegram";
+    console.log(chalk7.green(`Bot ready. Run: vizzor bot start ${which}`));
   }
-  return instance;
 }
-var instance;
-var init_store_factory = __esm({
-  "src/data/store-factory.ts"() {
+var init_bot3 = __esm({
+  "src/cli/commands/bot.ts"() {
     "use strict";
-    init_sqlite_store();
-    instance = null;
+    init_loader();
+    init_keys();
   }
 });
 
 // src/data/collector.ts
-var log, MAJOR_SYMBOLS, TIMEFRAMES, COLLECTION_INTERVAL_MS, DataCollector;
+var log2, MAJOR_SYMBOLS, TIMEFRAMES, COLLECTION_INTERVAL_MS, DataCollector;
 var init_collector = __esm({
   "src/data/collector.ts"() {
     "use strict";
     init_binance();
     init_logger();
-    log = createLogger("collector");
+    log2 = createLogger("collector");
     MAJOR_SYMBOLS = [
       "BTC",
       "ETH",
@@ -8611,10 +8841,10 @@ var init_collector = __esm({
       }
       start() {
         if (this.status.running) {
-          log.warn("Collector already running");
+          log2.warn("Collector already running");
           return;
         }
-        log.info(
+        log2.info(
           `Starting data collector: ${this.symbols.length} symbols, ${TIMEFRAMES.length} timeframes, every ${this.intervalMs / 1e3}s`
         );
         this.status.running = true;
@@ -8627,10 +8857,10 @@ var init_collector = __esm({
           this.timer = null;
         }
         this.status.running = false;
-        log.info("Data collector stopped");
+        log2.info("Data collector stopped");
       }
       async collectAll() {
-        log.info("Collection cycle starting");
+        log2.info("Collection cycle starting");
         const start = Date.now();
         for (const timeframe of TIMEFRAMES) {
           for (const symbol of this.symbols) {
@@ -8638,7 +8868,7 @@ var init_collector = __esm({
               await this.collectSymbol(symbol, timeframe);
             } catch (err) {
               this.status.errors++;
-              log.error(
+              log2.error(
                 `Failed to collect ${symbol}/${timeframe}: ${err instanceof Error ? err.message : String(err)}`
               );
             }
@@ -8646,7 +8876,7 @@ var init_collector = __esm({
         }
         this.status.lastRun = Date.now();
         const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
-        log.info(
+        log2.info(
           `Collection cycle complete in ${elapsed}s (total records: ${this.status.totalRecords})`
         );
       }
@@ -8733,6 +8963,481 @@ var init_collect = __esm({
   }
 });
 
+// src/api/routes/v1/market.ts
+async function registerMarketRoutes(server) {
+  server.get("/price/:symbol", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get live price and market data for a symbol",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_market_data", { symbol });
+    }
+  });
+  server.get("/trending", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get trending tokens from DEX and CoinGecko"
+    },
+    handler: async () => {
+      return handleTool("get_trending", {});
+    }
+  });
+  server.get("/fear-greed", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get Crypto Fear & Greed Index with history"
+    },
+    handler: async () => {
+      return handleTool("get_fear_greed", {});
+    }
+  });
+  server.get("/news", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get latest crypto news with sentiment",
+      querystring: {
+        type: "object",
+        properties: { symbol: { type: "string" } }
+      }
+    },
+    handler: async (request) => {
+      const { symbol } = request.query;
+      return handleTool("get_crypto_news", { symbol });
+    }
+  });
+  server.get("/dex/search", {
+    schema: {
+      tags: ["Market"],
+      summary: "Search tokens on decentralized exchanges",
+      querystring: {
+        type: "object",
+        properties: { q: { type: "string" } },
+        required: ["q"]
+      }
+    },
+    handler: async (request) => {
+      const { q } = request.query;
+      return handleTool("search_token_dex", { query: q });
+    }
+  });
+  server.get("/derivatives/:symbol", {
+    schema: {
+      tags: ["Market"],
+      summary: "Get derivatives data (funding rate, open interest)",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_derivatives_data", { symbol });
+    }
+  });
+}
+var init_market3 = __esm({
+  "src/api/routes/v1/market.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/routes/v1/analysis.ts
+async function registerAnalysisRoutes(server) {
+  server.get("/technical/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Run technical analysis on a symbol",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] },
+      querystring: {
+        type: "object",
+        properties: { timeframe: { type: "string", default: "4h" } }
+      }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      const { timeframe } = request.query;
+      return handleTool("get_technical_analysis", { symbol, timeframe });
+    }
+  });
+  server.get("/prediction/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Generate multi-signal composite prediction",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_prediction", { symbol });
+    }
+  });
+  server.get("/ml/:symbol", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Get ML-enhanced prediction from sidecar models",
+      params: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+    },
+    handler: async (request) => {
+      const { symbol } = request.params;
+      return handleTool("get_ml_prediction", { symbol });
+    }
+  });
+  server.get("/raises/recent", {
+    schema: {
+      tags: ["Analysis"],
+      summary: "Get recent crypto fundraising rounds",
+      querystring: {
+        type: "object",
+        properties: {
+          category: { type: "string" },
+          chain: { type: "string" }
+        }
+      }
+    },
+    handler: async (request) => {
+      const { category, chain } = request.query;
+      return handleTool("get_raises", { category, chain });
+    }
+  });
+}
+var init_analysis = __esm({
+  "src/api/routes/v1/analysis.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/routes/v1/security.ts
+async function registerSecurityRoutes(server) {
+  server.post("/token", {
+    schema: {
+      tags: ["Security"],
+      summary: "Check token security via GoPlus",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("get_token_security", { address, chain });
+    }
+  });
+  server.post("/rug-check", {
+    schema: {
+      tags: ["Security"],
+      summary: "Check token for rug pull indicators",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("check_rug_indicators", { address, chain });
+    }
+  });
+  server.post("/wallet", {
+    schema: {
+      tags: ["Security"],
+      summary: "Analyze a wallet address",
+      body: {
+        type: "object",
+        properties: {
+          address: { type: "string" },
+          chain: { type: "string", default: "ethereum" }
+        },
+        required: ["address"]
+      }
+    },
+    handler: async (request) => {
+      const { address, chain } = request.body;
+      return handleTool("analyze_wallet", { address, chain });
+    }
+  });
+}
+var init_security = __esm({
+  "src/api/routes/v1/security.ts"() {
+    "use strict";
+    init_tool_handler();
+  }
+});
+
+// src/api/auth/keys.ts
+import { randomBytes, scryptSync } from "crypto";
+function hashApiKey(key) {
+  return scryptSync(key, API_KEY_SALT, 64).toString("hex");
+}
+function ensureKeysTable() {
+  getDb().exec(`
+    CREATE TABLE IF NOT EXISTS api_keys (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      key_hash TEXT NOT NULL UNIQUE,
+      key_prefix TEXT NOT NULL,
+      rate_limit INTEGER NOT NULL DEFAULT 100,
+      created_at INTEGER NOT NULL,
+      revoked_at INTEGER
+    )
+  `);
+}
+function createApiKey(label) {
+  ensureKeysTable();
+  const rawKey = `vzr_${randomBytes(32).toString("hex")}`;
+  const keyHash = hashApiKey(rawKey);
+  const keyPrefix = rawKey.slice(0, 12) + "...";
+  const id = randomBytes(16).toString("hex");
+  const now = Date.now();
+  getDb().prepare(
+    `INSERT INTO api_keys (id, label, key_hash, key_prefix, rate_limit, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(id, label, keyHash, keyPrefix, 100, now);
+  return {
+    key: rawKey,
+    record: { id, label, keyPrefix, rateLimit: 100, createdAt: now, revokedAt: null }
+  };
+}
+function listApiKeys() {
+  ensureKeysTable();
+  const rows = getDb().prepare("SELECT * FROM api_keys WHERE revoked_at IS NULL ORDER BY created_at DESC").all();
+  return rows.map((r) => ({
+    id: r.id,
+    label: r.label,
+    keyPrefix: r.key_prefix,
+    rateLimit: r.rate_limit,
+    createdAt: r.created_at,
+    revokedAt: r.revoked_at
+  }));
+}
+function revokeApiKey(id) {
+  ensureKeysTable();
+  const result = getDb().prepare("UPDATE api_keys SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL").run(Date.now(), id);
+  return result.changes > 0;
+}
+var API_KEY_SALT;
+var init_keys2 = __esm({
+  "src/api/auth/keys.ts"() {
+    "use strict";
+    init_cache();
+    API_KEY_SALT = "vizzor-api-key-v1";
+  }
+});
+
+// src/api/auth/middleware.ts
+async function authMiddleware(request, reply) {
+  if (PUBLIC_PATHS.some((p) => request.url === p) || request.url.startsWith("/docs/")) {
+    return;
+  }
+  const apiKey = request.headers["x-api-key"];
+  if (!apiKey) {
+    return reply.status(401).send({
+      error: "Unauthorized",
+      message: "Missing X-API-Key header"
+    });
+  }
+  const keyHash = hashApiKey(apiKey);
+  const valid = await validateKey2(keyHash);
+  if (!valid) {
+    return reply.status(403).send({
+      error: "Forbidden",
+      message: "Invalid API key"
+    });
+  }
+}
+async function validateKey2(keyHash) {
+  const store = getStoreInstance();
+  if (!store) return false;
+  const cached = await store.getCached(`apikey:${keyHash}`);
+  if (cached !== null) return cached.valid;
+  return true;
+}
+var PUBLIC_PATHS;
+var init_middleware = __esm({
+  "src/api/auth/middleware.ts"() {
+    "use strict";
+    init_keys2();
+    init_store_factory();
+    PUBLIC_PATHS = ["/health", "/docs", "/docs/"];
+  }
+});
+
+// src/api/middleware/error-handler.ts
+function errorHandler(error, _request, reply) {
+  if (error.statusCode === 429) {
+    void reply.status(429).send({
+      error: "Too Many Requests",
+      message: "Rate limit exceeded. Try again later."
+    });
+    return;
+  }
+  const status = error.statusCode ?? 500;
+  void reply.status(status).send({
+    error: error.name ?? "InternalError",
+    message: status >= 500 ? "Internal server error" : error.message
+  });
+}
+var init_error_handler = __esm({
+  "src/api/middleware/error-handler.ts"() {
+    "use strict";
+  }
+});
+
+// src/api/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startApiServer: () => startApiServer
+});
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import rateLimit from "@fastify/rate-limit";
+import swagger from "@fastify/swagger";
+import swaggerUi from "@fastify/swagger-ui";
+async function startApiServer(options) {
+  const server = Fastify({ logger: false });
+  await server.register(cors, { origin: true });
+  await server.register(rateLimit, {
+    max: 100,
+    timeWindow: "1 minute"
+  });
+  await server.register(swagger, {
+    openapi: {
+      info: {
+        title: "Vizzor API",
+        description: "AI-powered crypto intelligence REST API",
+        version: "0.7.0"
+      },
+      servers: [{ url: `http://${options.host}:${options.port}` }],
+      components: {
+        securitySchemes: {
+          apiKey: {
+            type: "apiKey",
+            name: "X-API-Key",
+            in: "header"
+          }
+        }
+      }
+    }
+  });
+  await server.register(swaggerUi, {
+    routePrefix: "/docs"
+  });
+  if (options.enableAuth) {
+    server.addHook("onRequest", authMiddleware);
+  }
+  server.setErrorHandler(errorHandler);
+  server.get("/health", async () => ({
+    status: "ok",
+    version: "0.7.0",
+    uptime: process.uptime(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  await server.register(registerMarketRoutes, { prefix: "/v1/market" });
+  await server.register(registerAnalysisRoutes, { prefix: "/v1/analysis" });
+  await server.register(registerSecurityRoutes, { prefix: "/v1/security" });
+  await server.listen({ port: options.port, host: options.host });
+  log3.info(`Vizzor API listening on ${options.host}:${options.port}`);
+  log3.info(`OpenAPI docs at http://${options.host}:${options.port}/docs`);
+}
+var log3;
+var init_server = __esm({
+  "src/api/server.ts"() {
+    "use strict";
+    init_logger();
+    init_market3();
+    init_analysis();
+    init_security();
+    init_middleware();
+    init_error_handler();
+    log3 = createLogger("api");
+  }
+});
+
+// src/cli/commands/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  handleServe: () => handleServe
+});
+import chalk9 from "chalk";
+async function handleServe(options) {
+  console.log(chalk9.bold("Starting Vizzor REST API..."));
+  const { startApiServer: startApiServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startApiServer2({
+    port: options.port,
+    host: options.host,
+    enableAuth: options.auth
+  });
+  console.log(chalk9.green(`API running on http://${options.host}:${options.port}`));
+  console.log(chalk9.dim(`Docs: http://${options.host}:${options.port}/docs`));
+  console.log(chalk9.dim("\nPress Ctrl+C to stop"));
+  process.on("SIGINT", () => {
+    console.log(chalk9.yellow("\nShutting down..."));
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+var init_serve = __esm({
+  "src/cli/commands/serve.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/api.ts
+var api_exports = {};
+__export(api_exports, {
+  handleApiKeyCreate: () => handleApiKeyCreate,
+  handleApiKeyList: () => handleApiKeyList,
+  handleApiKeyRevoke: () => handleApiKeyRevoke
+});
+import chalk10 from "chalk";
+function handleApiKeyCreate(label) {
+  const { key, record } = createApiKey(label || "default");
+  console.log(chalk10.green("API key created successfully!"));
+  process.stdout.write(chalk10.bold(`
+  Key: ${key}
+
+`));
+  console.log(chalk10.yellow("  Save this key \u2014 it will not be shown again."));
+  console.log(`  Label: ${record.label}`);
+  console.log(`  ID: ${record.id}`);
+}
+function handleApiKeyList() {
+  const keys = listApiKeys();
+  if (keys.length === 0) {
+    console.log(chalk10.dim("No API keys found. Create one with: vizzor api key create [label]"));
+    return;
+  }
+  console.log(chalk10.bold("Active API Keys\n"));
+  for (const k of keys) {
+    console.log(`  ${chalk10.cyan(k.keyPrefix)}  ${k.label}  (${k.id.slice(0, 8)})`);
+    console.log(`    Rate limit: ${k.rateLimit} req/min`);
+    console.log(`    Created: ${new Date(k.createdAt).toISOString()}
+`);
+  }
+}
+function handleApiKeyRevoke(id) {
+  const revoked = revokeApiKey(id);
+  if (revoked) {
+    console.log(chalk10.green(`API key ${id} revoked.`));
+  } else {
+    console.log(chalk10.red(`No active key found with ID: ${id}`));
+  }
+}
+var init_api = __esm({
+  "src/cli/commands/api.ts"() {
+    "use strict";
+    init_keys2();
+  }
+});
+
 // src/tui/components/status-bar.tsx
 import React, { useState, useEffect } from "react";
 import { Box, Text, Spacer } from "ink";
@@ -9473,7 +10178,7 @@ function useAIStream() {
 var init_use_ai_stream = __esm({
   "src/tui/hooks/use-ai-stream.ts"() {
     "use strict";
-    init_client();
+    init_client2();
     init_chat();
     init_tools();
     init_context_injector();
@@ -9908,8 +10613,8 @@ async function handleConfig(args2) {
     }
     const isSensitive = key.toLowerCase().includes("key") || key.toLowerCase().includes("token");
     if (isSensitive) {
-      const { validateKey: validateKey2 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
-      const error = validateKey2(key, value);
+      const { validateKey: validateKey3 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
+      const error = validateKey3(key, value);
       if (error && !error.startsWith("Warning:")) {
         return { blocks: [], text: `Rejected: ${error}` };
       }
@@ -10025,7 +10730,7 @@ var init_commands3 = __esm({
     init_constants();
     init_binance();
     init_agent();
-    init_client();
+    init_client2();
     init_registry2();
     init_types();
   }
@@ -10467,7 +11172,7 @@ var init_app = __esm({
     init_commands3();
     init_loader();
     init_constants();
-    init_client();
+    init_client2();
     init_tool_handler();
     init_tools();
     init_binance();
@@ -10539,6 +11244,24 @@ collectCmd.command("status").description("Show data collection status").action(a
   const { handleCollectStatus: handleCollectStatus2 } = await Promise.resolve().then(() => (init_collect(), collect_exports));
   handleCollectStatus2();
 });
+program.command("serve").description("Start the REST API server").option("--port <port>", "Server port", parseInt, 3e3).option("--host <host>", "Server host", "0.0.0.0").option("--auth", "Enable API key authentication", false).action(async (options) => {
+  const { handleServe: handleServe2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
+  await handleServe2(options);
+});
+var apiCmd = program.command("api").description("API management");
+var apiKeyCmd = apiCmd.command("key").description("API key management");
+apiKeyCmd.command("create [label]").description("Generate a new API key").action(async (label) => {
+  const { handleApiKeyCreate: handleApiKeyCreate2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyCreate2(label);
+});
+apiKeyCmd.command("list").description("List active API keys").action(async () => {
+  const { handleApiKeyList: handleApiKeyList2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyList2();
+});
+apiKeyCmd.command("revoke <id>").description("Revoke an API key").action(async (id) => {
+  const { handleApiKeyRevoke: handleApiKeyRevoke2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  handleApiKeyRevoke2(id);
+});
 var args = process.argv.slice(2);
 if (args.length === 0) {
   await loadConfig();