horizon-code 0.2.0 → 0.3.1

package/src/research/tools.ts

@@ -3,9 +3,13 @@ import { tool } from "ai";
 import { z } from "zod";
 import {
   gammaEvents, gammaEventDetail, clobPriceHistory, clobOrderBook,
-  polymarketTrades, kalshiEvents, exaSearch, exaSentiment,
-  calaSearch, evCalculator, probabilityCalc,
+  polymarketTrades, kalshiEvents, kalshiEventDetail as kalshiEventDetailApi,
+  kalshiOrderBook as kalshiOrderBookApi, kalshiPriceHistory as kalshiPriceHistoryApi,
+  getMarketTrades, getWalletTrades, getWalletPositions, getWalletProfile,
+  resolveConditionId,
+  exaSearch, exaSentiment, calaSearch, evCalculator, probabilityCalc,
 } from "./apis.ts";
+import { yahooQuote, yahooChart, yahooSearch } from "./stock-apis.ts";
 
 const t = tool as any;
 
@@ -127,37 +131,76 @@ export const researchTools: Record<string, any> = {
   }),
 
   historicalVolatility: t({
-    description: "Calculate realized volatility, Bollinger bands, and volatility regime for a market.",
+    description: "Multi-estimator volatility analysis: close-to-close, Parkinson (high-low), Garman-Klass, and EWMA. Shows volatility regime and best estimate.",
     parameters: z.object({
       slug: z.string().describe("Event slug"),
       interval: z.string().optional().describe("Time range: 1d, 1w, 1m, max (default 1w)"),
     }),
     execute: async (args: any) => {
       const data = await clobPriceHistory(args.slug, args.interval ?? "1w", 60);
-      const prices = data.priceHistory.map((p: any) => p.p);
-      if (prices.length < 3) return { ...data, realizedVolatility: 0, regime: "insufficient data" };
+      const prices: number[] = data.priceHistory.map((p: any) => p.p);
+      if (prices.length < 5) return { ...data, realizedVolatility: 0, regime: "insufficient data" };
 
-      // Log returns
+      const annFactor = Math.sqrt(365 * 24); // hourly data
+
+      // Close-to-close (realized)
       const returns: number[] = [];
       for (let i = 1; i < prices.length; i++) {
         if (prices[i - 1] > 0) returns.push(Math.log(prices[i] / prices[i - 1]));
       }
-
       const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
       const variance = returns.reduce((a, b) => a + (b - mean) ** 2, 0) / returns.length;
-      const stdDev = Math.sqrt(variance);
-      const annualized = +(stdDev * Math.sqrt(365 * 24)).toFixed(4);
+      const closeToClose = +(Math.sqrt(variance) * annFactor).toFixed(4);
+
+      // Parkinson (uses range as proxy — estimate from consecutive prices)
+      // For each pair, treat as high/low estimate
+      let parkinsonSum = 0;
+      for (let i = 1; i < prices.length; i++) {
+        const hi = Math.max(prices[i], prices[i - 1]);
+        const lo = Math.min(prices[i], prices[i - 1]);
+        if (lo > 0) parkinsonSum += Math.log(hi / lo) ** 2;
+      }
+      const parkinson = +(Math.sqrt(parkinsonSum / ((prices.length - 1) * 4 * Math.LN2)) * annFactor).toFixed(4);
+
+      // Garman-Klass (open-high-low-close)
+      // Simplified: uses consecutive 3-bar windows
+      let gkSum = 0;
+      for (let i = 2; i < prices.length; i++) {
+        const open = prices[i - 2], close = prices[i];
+        const hi = Math.max(prices[i - 2], prices[i - 1], prices[i]);
+        const lo = Math.min(prices[i - 2], prices[i - 1], prices[i]);
+        if (lo > 0 && open > 0) {
+          gkSum += 0.5 * Math.log(hi / lo) ** 2 - (2 * Math.LN2 - 1) * Math.log(close / open) ** 2;
+        }
+      }
+      const garmanKlass = +(Math.sqrt(Math.max(0, gkSum / (prices.length - 2))) * annFactor).toFixed(4);
 
-      // Regime
+      // EWMA (exponentially weighted, lambda=0.94)
+      const lambda = 0.94;
+      let ewmaVar = variance;
+      for (let i = returns.length - 1; i >= 0; i--) {
+        ewmaVar = lambda * ewmaVar + (1 - lambda) * returns[i] ** 2;
+      }
+      const ewma = +(Math.sqrt(ewmaVar) * annFactor).toFixed(4);
+
+      // Best estimate: median of all 4
+      const estimates = [closeToClose, parkinson, garmanKlass, ewma].sort((a, b) => a - b);
+      const best = +((estimates[1] + estimates[2]) / 2).toFixed(4);
+
+      // Regime from recent vs full-period vol
       const recentReturns = returns.slice(-20);
-      const recentVar = recentReturns.reduce((a, b) => a + (b - mean) ** 2, 0) / recentReturns.length;
-      const recentVol = Math.sqrt(recentVar);
-      const regime = recentVol > stdDev * 1.5 ? "high" : recentVol < stdDev * 0.5 ? "low" : "normal";
+      const recentVar = recentReturns.reduce((a, b) => a + b ** 2, 0) / recentReturns.length;
+      const recentVol = Math.sqrt(recentVar) * annFactor;
+      const regime = recentVol > best * 1.5 ? "high" : recentVol < best * 0.5 ? "low" : "normal";
 
       return {
         ...data,
-        realizedVolatility: annualized,
-        dailyStdDev: +stdDev.toFixed(6),
+        estimators: {
+          closeToClose, parkinson, garmanKlass, ewma, best,
+        },
+        realizedVolatility: best,
+        dailyStdDev: +(Math.sqrt(variance)).toFixed(6),
+        recentVolatility: +(recentVol).toFixed(4),
         volatilityRegime: regime,
       };
     },
@@ -184,11 +227,11 @@ export const researchTools: Record<string, any> = {
           const score = overlap / Math.max(pWords.size, kWords.length);
           if (score > 0.3) {
             const polyPrice = parseFloat(p.markets?.[0]?.yesPrice ?? "0");
-            const kalPrice = k.markets?.[0]?.yesBid ?? 0;
+            const kalPrice = k.markets?.[0]?.yesBid ?? k.markets?.[0]?.lastPrice ?? 0;
             comparisons.push({
               polymarket: { title: p.title, url: p.url, yesPrice: polyPrice },
               kalshi: { title: k.title, url: k.url, yesPrice: kalPrice },
-              priceDiff: polyPrice && kalPrice ? +(polyPrice - kalPrice / 100).toFixed(4) : null,
+              priceDiff: polyPrice && kalPrice ? +(polyPrice - kalPrice).toFixed(4) : null,
             });
           }
         }
@@ -202,4 +245,873 @@ export const researchTools: Record<string, any> = {
       };
     },
   }),
+
+  // ── Kalshi deep tools ──
+
+  kalshiEventDetail: t({
+    description: "Get detailed info on a specific Kalshi event including all markets, spreads, and volumes. Requires event ticker from kalshiEvents.",
+    parameters: z.object({
+      ticker: z.string().describe("Kalshi event ticker (e.g. KXBTC-25MAR14)"),
+    }),
+    execute: async (args: any) => kalshiEventDetailApi(args.ticker),
+  }),
+
+  kalshiOrderBook: t({
+    description: "Get order book depth and bid/ask levels for a Kalshi market. Shows liquidity and spread.",
+    parameters: z.object({
+      ticker: z.string().describe("Kalshi market ticker (e.g. KXBTC-25MAR14-T84999)"),
+    }),
+    execute: async (args: any) => kalshiOrderBookApi(args.ticker),
+  }),
+
+  kalshiPriceHistory: t({
+    description: "Get price history (candlesticks) for a Kalshi market. Good for trend analysis.",
+    parameters: z.object({
+      ticker: z.string().describe("Kalshi market ticker"),
+      period: z.string().optional().describe("Time range: 1h, 6h, 1d, 1w, 1m, max (default 1w)"),
+    }),
+    execute: async (args: any) => kalshiPriceHistoryApi(args.ticker, args.period),
+  }),
+
+  // ── Analysis tools ──
+
+  marketMicrostructure: t({
+    description: "Analyze market microstructure: depth imbalance, effective spread, Kyle's lambda (price impact), and liquidity score. Uses order book data.",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+      marketIndex: z.number().optional().describe("Sub-market index (default 0)"),
+    }),
+    execute: async (args: any) => {
+      const book = await clobOrderBook(args.slug, args.marketIndex ?? 0, 0);
+      const bids: { price: number; size: number }[] = book.bids ?? [];
+      const asks: { price: number; size: number }[] = book.asks ?? [];
+
+      // Depth imbalance: (bid_volume - ask_volume) / (bid_volume + ask_volume)
+      const bidVol = bids.reduce((s, l) => s + l.size, 0);
+      const askVol = asks.reduce((s, l) => s + l.size, 0);
+      const totalVol = bidVol + askVol || 1;
+      const depthImbalance = +((bidVol - askVol) / totalVol).toFixed(4);
+
+      // Effective spread: difference between best bid and ask
+      const bestBid = bids[0]?.price ?? 0;
+      const bestAsk = asks[0]?.price ?? 1;
+      const midPrice = (bestBid + bestAsk) / 2;
+      const effectiveSpread = +(bestAsk - bestBid).toFixed(4);
+      const spreadBps = midPrice > 0 ? +((effectiveSpread / midPrice) * 10000).toFixed(0) : 0;
+
+      // Kyle's lambda estimate: price impact per unit of order flow
+      // Approximation: spread / (2 * average_depth_at_top_3_levels)
+      const top3BidDepth = bids.slice(0, 3).reduce((s, l) => s + l.size, 0);
+      const top3AskDepth = asks.slice(0, 3).reduce((s, l) => s + l.size, 0);
+      const avgDepth = (top3BidDepth + top3AskDepth) / 2 || 1;
+      const kyleLambda = +(effectiveSpread / (2 * avgDepth)).toFixed(6);
+
+      // Depth at price levels
+      const depthLevels = [];
+      for (let i = 0; i < Math.min(5, Math.max(bids.length, asks.length)); i++) {
+        depthLevels.push({
+          level: i + 1,
+          bidPrice: bids[i]?.price ?? null,
+          bidSize: bids[i]?.size ?? 0,
+          askPrice: asks[i]?.price ?? null,
+          askSize: asks[i]?.size ?? 0,
+        });
+      }
+
+      // Liquidity score: composite (0-100)
+      // Based on: tighter spread = better, more depth = better, more balanced = better
+      const spreadScore = Math.max(0, 100 - spreadBps * 2); // 50bps = 0 score
+      const depthScore = Math.min(100, (totalVol / 100) * 10); // 1000 contracts = 100
+      const balanceScore = (1 - Math.abs(depthImbalance)) * 100;
+      const liquidityScore = Math.round((spreadScore * 0.4 + depthScore * 0.4 + balanceScore * 0.2));
+
+      return {
+        title: book.title, slug: args.slug, url: book.url,
+        midPrice: +midPrice.toFixed(4),
+        effectiveSpread, spreadBps,
+        depthImbalance,
+        depthImbalanceLabel: depthImbalance > 0.3 ? "bid heavy" : depthImbalance < -0.3 ? "ask heavy" : "balanced",
+        kyleLambda,
+        kyleLambdaLabel: kyleLambda > 0.01 ? "high impact" : kyleLambda > 0.001 ? "moderate" : "low impact",
+        bidVolume: bidVol, askVolume: askVol,
+        liquidityScore,
+        liquidityLabel: liquidityScore >= 70 ? "excellent" : liquidityScore >= 40 ? "adequate" : "thin",
+        depthLevels,
+      };
+    },
+  }),
+
+  liquidityScanner: t({
+    description: "Scan top Polymarket markets and rank them by liquidity, spread, and volume. Great for finding the best markets to trade.",
+    parameters: z.object({
+      query: z.string().optional().describe("Optional filter (e.g. crypto, politics)"),
+      limit: z.number().optional().describe("Number of markets to scan (1-10, default 5)"),
+    }),
+    execute: async (args: any) => {
+      const events = await gammaEvents({ query: args.query, limit: Math.min(args.limit ?? 5, 10) });
+      const results = [];
+
+      for (const e of events) {
+        const market = e.markets?.[0];
+        if (!market) continue;
+
+        const bid = parseFloat(market.bestBid ?? "0");
+        const ask = parseFloat(market.bestAsk ?? "1");
+        const spread = ask - bid;
+        const spreadPct = bid > 0 ? spread / ((bid + ask) / 2) : 0;
+
+        results.push({
+          title: e.title, slug: e.slug,
+          yesPrice: market.yesPrice ? parseFloat(market.yesPrice) : null,
+          volume24h: e.volume24hr ?? 0,
+          liquidity: e.liquidity ?? 0,
+          spread: +spread.toFixed(4),
+          spreadPct: +(spreadPct * 100).toFixed(2),
+          bestBid: bid, bestAsk: ask,
+        });
+      }
+
+      // Sort by liquidity descending
+      results.sort((a, b) => b.liquidity - a.liquidity);
+
+      return {
+        query: args.query ?? "top markets",
+        markets: results,
+        summary: {
+          avgSpread: +(results.reduce((s, r) => s + r.spreadPct, 0) / (results.length || 1)).toFixed(2),
+          totalLiquidity: results.reduce((s, r) => s + r.liquidity, 0),
+          totalVolume24h: results.reduce((s, r) => s + r.volume24h, 0),
+          tightestSpread: results.length > 0 ? results.reduce((best, r) => r.spreadPct < best.spreadPct ? r : best).title : null,
+          deepestLiquidity: results.length > 0 ? results[0].title : null,
+        },
+      };
+    },
+  }),
+
+  correlationAnalysis: t({
+    description: "Analyze price correlation between two Polymarket markets. Shows if markets move together, apart, or independently.",
+    parameters: z.object({
+      slugA: z.string().describe("First market slug"),
+      slugB: z.string().describe("Second market slug"),
+      interval: z.string().optional().describe("Time range: 1d, 1w, 1m (default 1w)"),
+    }),
+    execute: async (args: any) => {
+      const interval = args.interval ?? "1w";
+      const [a, b] = await Promise.all([
+        clobPriceHistory(args.slugA, interval, 60),
+        clobPriceHistory(args.slugB, interval, 60),
+      ]);
+
+      const pricesA = (a.priceHistory ?? []).map((p: any) => p.p);
+      const pricesB = (b.priceHistory ?? []).map((p: any) => p.p);
+
+      // Align to same length (shorter series)
+      const len = Math.min(pricesA.length, pricesB.length);
+      if (len < 5) {
+        return { error: "Not enough overlapping data points (need at least 5)" };
+      }
+
+      const pA = pricesA.slice(-len);
+      const pB = pricesB.slice(-len);
+
+      // Compute returns
+      const rA: number[] = [], rB: number[] = [];
+      for (let i = 1; i < len; i++) {
+        rA.push(pA[i] - pA[i - 1]);
+        rB.push(pB[i] - pB[i - 1]);
+      }
+
+      // Pearson correlation
+      const meanA = rA.reduce((s, v) => s + v, 0) / rA.length;
+      const meanB = rB.reduce((s, v) => s + v, 0) / rB.length;
+      let cov = 0, varA = 0, varB = 0;
+      for (let i = 0; i < rA.length; i++) {
+        const dA = rA[i] - meanA, dB = rB[i] - meanB;
+        cov += dA * dB;
+        varA += dA * dA;
+        varB += dB * dB;
+      }
+      const correlation = varA > 0 && varB > 0 ? +(cov / Math.sqrt(varA * varB)).toFixed(4) : 0;
+      const label = correlation > 0.7 ? "strong positive" : correlation > 0.3 ? "moderate positive"
+        : correlation > -0.3 ? "uncorrelated" : correlation > -0.7 ? "moderate negative" : "strong negative";
+
+      // Beta: how much B moves per unit of A
+      const beta = varA > 0 ? +(cov / varA).toFixed(4) : 0;
+
+      return {
+        marketA: { title: a.title, slug: args.slugA, current: a.current, change: a.change, priceHistory: pA },
+        marketB: { title: b.title, slug: args.slugB, current: b.current, change: b.change, priceHistory: pB },
+        correlation, label, beta,
+        dataPoints: len,
+        interval,
+        tradingImplication: correlation > 0.7 ? "Markets move together — hedge one with the other, or avoid doubling exposure"
+          : correlation < -0.7 ? "Markets move inversely — natural hedge pair, or pairs-trade opportunity"
+          : "Markets are largely independent — good for portfolio diversification",
+      };
+    },
+  }),
+
+  // ── Whale / Wallet analysis tools ──
+
+  walletProfiler: t({
+    description: "Analyze a Polymarket wallet: win rate, PnL, Sharpe ratio, edge category (smart_money/neutral/weak_hand/bot). Requires a wallet address (0x...).",
+    parameters: z.object({
+      address: z.string().describe("Wallet address (0x...)"),
+    }),
+    execute: async (args: any) => {
+      const [profile, positions, trades] = await Promise.all([
+        getWalletProfile(args.address),
+        getWalletPositions(args.address, 100),
+        getWalletTrades(args.address, 200),
+      ]);
+
+      // Win rate from positions
+      const closedPositions = positions.filter((p: any) => p.pnl !== undefined && p.pnl !== null);
+      const wins = closedPositions.filter((p: any) => (p.pnl ?? 0) > 0).length;
+      const winRate = closedPositions.length > 0 ? +(wins / closedPositions.length).toFixed(4) : 0;
+
+      // PnL stats
+      const pnls = closedPositions.map((p: any) => p.pnl_percent ?? p.pnl ?? 0);
+      const totalPnl = pnls.reduce((s: number, p: number) => s + p, 0);
+      const meanPnl = pnls.length > 0 ? totalPnl / pnls.length : 0;
+      const pnlVariance = pnls.length > 1 ? pnls.reduce((s: number, p: number) => s + (p - meanPnl) ** 2, 0) / pnls.length : 0;
+      const pnlStdDev = Math.sqrt(pnlVariance);
+      const sharpe = pnlStdDev > 0 ? +(meanPnl / pnlStdDev).toFixed(4) : 0;
+
+      // Sortino (downside deviation)
+      const downsidePnls = pnls.filter((p: number) => p < 0);
+      const downsideVar = downsidePnls.length > 0 ? downsidePnls.reduce((s: number, p: number) => s + p ** 2, 0) / downsidePnls.length : 0;
+      const sortino = Math.sqrt(downsideVar) > 0 ? +(meanPnl / Math.sqrt(downsideVar)).toFixed(4) : 0;
+
+      // Composite score (-1 to +1)
+      const normWinRate = (winRate - 0.5) * 2; // 0.5 → 0, 1.0 → 1
+      const normSharpe = Math.tanh(sharpe * 0.5);
+      const normPnl = Math.tanh(totalPnl * 0.01);
+      const composite = +(0.3 * normSharpe + 0.3 * normWinRate + 0.4 * normPnl).toFixed(4);
+
+      // Edge category
+      const edgeCategory = composite > 0.5 ? "smart_money" : composite > 0.1 ? "neutral"
+        : composite > -0.3 ? "weak_hand" : "bot_or_losing";
+
+      // Trade stats
+      const buyCount = trades.filter((t: any) => t.side === "BUY").length;
+      const avgSize = trades.length > 0 ? +(trades.reduce((s: number, t: any) => s + (t.size ?? 0), 0) / trades.length).toFixed(0) : 0;
+
+      // Top markets by position size
+      const topPositions = positions
+        .sort((a: any, b: any) => Math.abs(b.current_value ?? 0) - Math.abs(a.current_value ?? 0))
+        .slice(0, 5)
+        .map((p: any) => ({
+          market: p.market_slug ?? p.condition_id ?? "unknown",
+          outcome: p.outcome ?? "YES",
+          size: p.size ?? 0, avgPrice: p.avg_price ?? 0,
+          currentValue: p.current_value ?? 0,
+          pnl: p.pnl ?? 0, pnlPct: p.pnl_percent ?? 0,
+        }));
+
+      return {
+        ...profile,
+        stats: {
+          winRate, totalPnl: +totalPnl.toFixed(2), meanPnl: +meanPnl.toFixed(4),
+          sharpe, sortino, composite, edgeCategory,
+          totalPositions: positions.length, closedPositions: closedPositions.length,
+          totalTrades: trades.length, buyRatio: trades.length > 0 ? +(buyCount / trades.length).toFixed(2) : 0,
+          avgTradeSize: avgSize,
+        },
+        topPositions,
+      };
+    },
+  }),
+
+  botDetector: t({
+    description: "Detect bots in a Polymarket market. Analyzes top traders' timing, sizing, and behavior to classify as bot/human with strategy type (market_maker, grid_bot, momentum, sniper, human).",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+    }),
+    execute: async (args: any) => {
+      const { conditionId, title } = await resolveConditionId(args.slug);
+      const trades = await getMarketTrades(conditionId, 500);
+
+      // Group trades by wallet
+      const byWallet = new Map<string, any[]>();
+      for (const t of trades) {
+        const addr = t.maker_address ?? t.taker_address ?? "unknown";
+        if (!byWallet.has(addr)) byWallet.set(addr, []);
+        byWallet.get(addr)!.push(t);
+      }
+
+      // Analyze top traders (by trade count)
+      const wallets = [...byWallet.entries()]
+        .sort((a, b) => b[1].length - a[1].length)
+        .slice(0, 10);
+
+      const results = [];
+      for (const [address, wTrades] of wallets) {
+        if (wTrades.length < 3) continue;
+
+        // Timing analysis
+        const timestamps = wTrades.map((t: any) => new Date(t.created_at ?? 0).getTime()).sort((a: number, b: number) => a - b);
+        const intervals: number[] = [];
+        for (let i = 1; i < timestamps.length; i++) intervals.push(timestamps[i] - timestamps[i - 1]);
+
+        const meanInterval = intervals.length > 0 ? intervals.reduce((a, b) => a + b, 0) / intervals.length : 0;
+        const stdInterval = intervals.length > 1 ? Math.sqrt(intervals.reduce((s, v) => s + (v - meanInterval) ** 2, 0) / intervals.length) : 0;
+        const timingCV = meanInterval > 0 ? +(stdInterval / meanInterval).toFixed(3) : 999;
+
+        // Size analysis
+        const sizes = wTrades.map((t: any) => t.size ?? 0);
+        const meanSize = sizes.reduce((a: number, b: number) => a + b, 0) / sizes.length;
+        const stdSize = Math.sqrt(sizes.reduce((s: number, v: number) => s + (v - meanSize) ** 2, 0) / sizes.length);
+        const sizeCV = meanSize > 0 ? +(stdSize / meanSize).toFixed(3) : 999;
+
+        // Trade frequency (trades per hour)
+        const timeSpanHrs = timestamps.length > 1 ? (timestamps[timestamps.length - 1] - timestamps[0]) / 3600000 : 1;
+        const tradeFreq = +(wTrades.length / Math.max(timeSpanHrs, 0.01)).toFixed(2);
+
+        // Buy ratio
+        const buys = wTrades.filter((t: any) => t.side === "BUY").length;
+        const buyRatio = +(buys / wTrades.length).toFixed(3);
+        const imbalance = Math.abs(buyRatio - 0.5) * 2;
+
+        // Sub-second trades
+        const fastTrades = intervals.filter(i => i < 2000).length;
+        const fastRatio = intervals.length > 0 ? +(fastTrades / intervals.length).toFixed(3) : 0;
+
+        // Size regularity
+        const sizeRegularity = sizeCV < 0.3 ? 1 : sizeCV < 0.6 ? 0.5 : 0;
+
+        // Classify strategy type
+        let strategyType = "human";
+        let isBot = false;
+
+        if (imbalance < 0.15 && tradeFreq > 10 && sizeRegularity > 0.5 && timingCV < 0.5) {
+          strategyType = "market_maker"; isBot = true;
+        } else if (sizeRegularity > 0.7 && imbalance < 0.3 && tradeFreq >= 2 && tradeFreq <= 50) {
+          strategyType = "grid_bot"; isBot = true;
+        } else if (imbalance > 0.6 && tradeFreq > 5) {
+          strategyType = "momentum"; isBot = true;
+        } else if (fastRatio > 0.3 && meanSize > 100 && wTrades.length < 20) {
+          strategyType = "sniper"; isBot = true;
+        } else if (timingCV < 0.3 || (tradeFreq > 20 && sizeCV < 0.4)) {
+          strategyType = "unknown_bot"; isBot = true;
+        }
+
+        const name = wTrades[0]?.maker_name ?? address.slice(0, 8) + "...";
+        results.push({
+          address: address.slice(0, 10) + "...", name,
+          trades: wTrades.length, isBot, strategyType,
+          tradeFreq, timingCV, sizeCV, buyRatio, fastRatio,
+          avgSize: +meanSize.toFixed(0),
+          totalVolume: +sizes.reduce((a: number, b: number) => a + b, 0).toFixed(0),
+        });
+      }
+
+      const botCount = results.filter(r => r.isBot).length;
+      const humanCount = results.length - botCount;
+
+      return {
+        title, slug: args.slug,
+        totalTradesAnalyzed: trades.length,
+        uniqueWallets: byWallet.size,
+        topTraders: results,
+        summary: {
+          bots: botCount, humans: humanCount,
+          botPct: results.length > 0 ? +((botCount / results.length) * 100).toFixed(0) : 0,
+          strategies: {
+            market_maker: results.filter(r => r.strategyType === "market_maker").length,
+            grid_bot: results.filter(r => r.strategyType === "grid_bot").length,
+            momentum: results.filter(r => r.strategyType === "momentum").length,
+            sniper: results.filter(r => r.strategyType === "sniper").length,
+            human: humanCount,
+          },
+        },
+      };
+    },
+  }),
+
+  marketFlow: t({
+    description: "Deep flow analysis for a Polymarket market: buy/sell volume split, wallet concentration (Herfindahl index), top movers, unique wallets.",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+      limit: z.number().optional().describe("Number of trades to analyze (50-500, default 200)"),
+    }),
+    execute: async (args: any) => {
+      const { conditionId, title } = await resolveConditionId(args.slug);
+      const trades = await getMarketTrades(conditionId, Math.min(args.limit ?? 200, 500));
+
+      // Basic flow
+      let buyVol = 0, sellVol = 0, buyCount = 0, sellCount = 0;
+      const walletVolumes = new Map<string, { buy: number; sell: number; name: string }>();
+
+      for (const t of trades) {
+        const size = t.size ?? 0;
+        const usdc = t.usdc_size ?? size * (t.price ?? 0.5);
+        const addr = t.maker_address ?? "unknown";
+        const name = t.maker_name ?? addr.slice(0, 8) + "...";
+
+        if (t.side === "BUY") { buyVol += usdc; buyCount++; }
+        else { sellVol += usdc; sellCount++; }
+
+        if (!walletVolumes.has(addr)) walletVolumes.set(addr, { buy: 0, sell: 0, name });
+        const w = walletVolumes.get(addr)!;
+        if (t.side === "BUY") w.buy += usdc; else w.sell += usdc;
+      }
+
+      const totalVol = buyVol + sellVol || 1;
+
+      // Herfindahl index (concentration)
+      const shares = [...walletVolumes.values()].map(w => ((w.buy + w.sell) / totalVol) ** 2);
+      const herfindahl = +(shares.reduce((s, v) => s + v, 0)).toFixed(4);
+      const concentrationLabel = herfindahl > 0.25 ? "highly concentrated"
+        : herfindahl > 0.15 ? "moderately concentrated" : "well distributed";
+
+      // Top movers
+      const topMovers = [...walletVolumes.entries()]
+        .map(([addr, w]) => ({
+          address: addr.slice(0, 10) + "...", name: w.name,
+          buyVol: +w.buy.toFixed(2), sellVol: +w.sell.toFixed(2),
+          total: +(w.buy + w.sell).toFixed(2),
+          direction: w.buy > w.sell ? "buyer" : "seller",
+          share: +((w.buy + w.sell) / totalVol * 100).toFixed(1),
+        }))
+        .sort((a, b) => b.total - a.total)
+        .slice(0, 8);
+
+      // Time distribution (bucket trades into 4 quarters)
+      const timestamps = trades.map((t: any) => new Date(t.created_at ?? 0).getTime()).filter((t: number) => t > 0);
+      const minTs = Math.min(...timestamps);
+      const maxTs = Math.max(...timestamps);
+      const range = maxTs - minTs || 1;
+      const buckets = [0, 0, 0, 0];
+      for (const ts of timestamps) {
+        const idx = Math.min(3, Math.floor(((ts - minTs) / range) * 4));
+        buckets[idx]++;
+      }
+
+      return {
+        title, slug: args.slug,
+        flow: {
+          buyVolume: +buyVol.toFixed(2), sellVolume: +sellVol.toFixed(2),
+          netFlow: +(buyVol - sellVol).toFixed(2),
+          direction: buyVol >= sellVol ? "inflow" : "outflow",
+          buyCount, sellCount, totalTrades: trades.length,
+          buyPct: +((buyVol / totalVol) * 100).toFixed(1),
+        },
+        concentration: {
+          herfindahl, label: concentrationLabel,
+          uniqueWallets: walletVolumes.size,
+          top3Share: topMovers.slice(0, 3).reduce((s, m) => s + m.share, 0),
+        },
+        topMovers,
+        timeDistribution: buckets,
+      };
+    },
+  }),
+
+  // ── Quant calculation tools ──
+
+  riskMetrics: t({
+    description: "Calculate risk metrics from price history: VaR, CVaR (expected shortfall), max drawdown, Sharpe ratio, Sortino ratio, Calmar ratio. Essential for position sizing.",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+      interval: z.string().optional().describe("Time range: 1d, 1w, 1m, max (default 1w)"),
+      confidenceLevel: z.number().optional().describe("VaR confidence level 0.90-0.99 (default 0.95)"),
+    }),
+    execute: async (args: any) => {
+      const data = await clobPriceHistory(args.slug, args.interval ?? "1w", 60);
+      const prices: number[] = data.priceHistory.map((p: any) => p.p);
+      if (prices.length < 10) return { ...data, error: "Need at least 10 data points" };
+
+      const confidence = args.confidenceLevel ?? 0.95;
+
+      // Returns
+      const returns: number[] = [];
+      for (let i = 1; i < prices.length; i++) {
+        if (prices[i - 1] > 0) returns.push((prices[i] - prices[i - 1]) / prices[i - 1]);
+      }
+
+      const meanReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+      const variance = returns.reduce((a, b) => a + (b - meanReturn) ** 2, 0) / returns.length;
+      const stdDev = Math.sqrt(variance);
+
+      // VaR (historical method)
+      const sortedReturns = [...returns].sort((a, b) => a - b);
+      const varIdx = Math.floor((1 - confidence) * sortedReturns.length);
+      const historicalVaR = +Math.abs(sortedReturns[varIdx] ?? 0).toFixed(6);
+
+      // CVaR (expected shortfall — average of returns worse than VaR)
+      const tailReturns = sortedReturns.slice(0, varIdx + 1);
+      const cvar = tailReturns.length > 0 ? +Math.abs(tailReturns.reduce((a, b) => a + b, 0) / tailReturns.length).toFixed(6) : historicalVaR;
+
+      // Max drawdown
+      let peak = prices[0], maxDD = 0, maxDDStart = 0, maxDDEnd = 0;
+      let currentDDStart = 0;
+      for (let i = 1; i < prices.length; i++) {
+        if (prices[i] > peak) { peak = prices[i]; currentDDStart = i; }
+        const dd = (peak - prices[i]) / peak;
+        if (dd > maxDD) { maxDD = dd; maxDDStart = currentDDStart; maxDDEnd = i; }
+      }
+
+      // Sharpe (annualized, assuming hourly data)
+      const annFactor = Math.sqrt(365 * 24);
+      const sharpe = stdDev > 0 ? +((meanReturn * annFactor * 365 * 24) / (stdDev * annFactor)).toFixed(4) : 0;
+
+      // Sortino
+      const downsideReturns = returns.filter(r => r < 0);
+      const downsideVar = downsideReturns.length > 0 ? downsideReturns.reduce((s, r) => s + r ** 2, 0) / downsideReturns.length : 0;
+      const downsideDev = Math.sqrt(downsideVar);
+      const sortino = downsideDev > 0 ? +((meanReturn * 365 * 24) / (downsideDev * annFactor)).toFixed(4) : 0;
+
+      // Calmar (annualized return / max drawdown)
+      const annualizedReturn = meanReturn * 365 * 24;
+      const calmar = maxDD > 0 ? +(annualizedReturn / maxDD).toFixed(4) : 0;
+
+      // Skewness and kurtosis
+      const skewness = stdDev > 0 ? +(returns.reduce((s, r) => s + ((r - meanReturn) / stdDev) ** 3, 0) / returns.length).toFixed(4) : 0;
+      const kurtosis = stdDev > 0 ? +(returns.reduce((s, r) => s + ((r - meanReturn) / stdDev) ** 4, 0) / returns.length - 3).toFixed(4) : 0;
+
+      return {
+        title: data.title, slug: args.slug, interval: args.interval ?? "1w",
+        dataPoints: prices.length,
+        riskMetrics: {
+          var: historicalVaR, varPct: +((historicalVaR * 100)).toFixed(2),
+          cvar, cvarPct: +((cvar * 100)).toFixed(2),
+          confidenceLevel: confidence,
+          maxDrawdown: +maxDD.toFixed(4), maxDrawdownPct: +((maxDD * 100)).toFixed(2),
+          drawdownPeriod: { start: maxDDStart, end: maxDDEnd, length: maxDDEnd - maxDDStart },
+        },
+        performanceMetrics: {
+          sharpe, sortino, calmar,
+          meanReturn: +meanReturn.toFixed(6),
+          annualizedReturn: +(annualizedReturn * 100).toFixed(2),
+          volatility: +(stdDev * annFactor * 100).toFixed(2),
+        },
+        distribution: {
+          skewness: +skewness, kurtosis: +kurtosis,
+          skewnessLabel: +skewness < -0.5 ? "left-skewed (tail risk)" : +skewness > 0.5 ? "right-skewed (upside)" : "symmetric",
+          kurtosisLabel: +kurtosis > 1 ? "fat tails (extreme events)" : +kurtosis < -1 ? "thin tails" : "normal",
+        },
+        priceHistory: prices,
+      };
+    },
+  }),
+
+  marketRegime: t({
+    description: "Detect market regime: is it trending, mean-reverting, or random? Uses Hurst exponent, variance ratio test, and return entropy.",
+    parameters: z.object({
+      slug: z.string().describe("Polymarket event slug"),
+      interval: z.string().optional().describe("Time range: 1d, 1w, 1m, max (default 1w)"),
+    }),
+    execute: async (args: any) => {
+      const data = await clobPriceHistory(args.slug, args.interval ?? "1w", 60);
+      const prices: number[] = data.priceHistory.map((p: any) => p.p);
+      if (prices.length < 20) return { ...data, error: "Need at least 20 data points" };
+
+      // Returns
+      const returns: number[] = [];
+      for (let i = 1; i < prices.length; i++) {
+        if (prices[i - 1] > 0) returns.push(Math.log(prices[i] / prices[i - 1]));
+      }
+
+      // ── Hurst Exponent (R/S method) ──
+      function computeHurst(series: number[]): number {
+        const n = series.length;
+        if (n < 20) return 0.5;
+
+        const rsValues: number[] = [];
+        const nValues: number[] = [];
+
+        for (let size = 10; size <= Math.floor(n / 2); size = Math.floor(size * 1.5)) {
+          const chunks = Math.floor(n / size);
+          let rsSum = 0;
+          for (let c = 0; c < chunks; c++) {
+            const chunk = series.slice(c * size, (c + 1) * size);
+            const mean = chunk.reduce((a, b) => a + b, 0) / chunk.length;
+            const deviations = chunk.map(v => v - mean);
+            const cumDev: number[] = [];
+            let cumSum = 0;
+            for (const d of deviations) { cumSum += d; cumDev.push(cumSum); }
+            const range = Math.max(...cumDev) - Math.min(...cumDev);
+            const stdDev = Math.sqrt(chunk.reduce((s, v) => s + (v - mean) ** 2, 0) / chunk.length);
+            if (stdDev > 0) rsSum += range / stdDev;
+          }
+          if (chunks > 0) {
+            rsValues.push(Math.log(rsSum / chunks));
+            nValues.push(Math.log(size));
+          }
+        }
+
+        // Linear regression log(R/S) = H * log(n) + c
+        if (rsValues.length < 2) return 0.5;
+        const meanX = nValues.reduce((a, b) => a + b, 0) / nValues.length;
+        const meanY = rsValues.reduce((a, b) => a + b, 0) / rsValues.length;
+        let num = 0, den = 0;
+        for (let i = 0; i < nValues.length; i++) {
+          num += (nValues[i] - meanX) * (rsValues[i] - meanY);
+          den += (nValues[i] - meanX) ** 2;
+        }
+        return den > 0 ? Math.max(0, Math.min(1, num / den)) : 0.5;
+      }
+
+      const hurst = +computeHurst(returns).toFixed(4);
+      const hurstLabel = hurst < 0.4 ? "mean-reverting" : hurst > 0.6 ? "trending" : "random walk";
+
+      // ── Variance Ratio Test (VR at lag 2, 5, 10) ──
+      function varianceRatio(series: number[], lag: number): number {
+        if (series.length < lag * 2) return 1;
+        const singleVar = series.reduce((s, r) => s + r ** 2, 0) / series.length;
+        const lagReturns: number[] = [];
+        for (let i = lag; i < series.length; i++) {
+          lagReturns.push(series.slice(i - lag, i).reduce((a, b) => a + b, 0));
+        }
+        const lagVar = lagReturns.reduce((s, r) => s + r ** 2, 0) / lagReturns.length;
+        return singleVar > 0 ? lagVar / (lag * singleVar) : 1;
+      }
+
+      const vr2 = +varianceRatio(returns, 2).toFixed(4);
+      const vr5 = +varianceRatio(returns, 5).toFixed(4);
+      const vr10 = +varianceRatio(returns, 10).toFixed(4);
+
+      // ── Shannon Entropy of return distribution ──
+      const bins = 20;
+      const minR = Math.min(...returns);
+      const maxR = Math.max(...returns);
+      const binWidth = (maxR - minR) / bins || 1;
+      const histogram = new Array(bins).fill(0);
+      for (const r of returns) {
+        const idx = Math.min(bins - 1, Math.floor((r - minR) / binWidth));
+        histogram[idx]++;
+      }
+      const totalR = returns.length;
+      let entropy = 0;
+      for (const count of histogram) {
+        if (count > 0) {
+          const p = count / totalR;
+          entropy -= p * Math.log2(p);
+        }
+      }
+      const maxEntropy = Math.log2(bins);
+      const normalizedEntropy = maxEntropy > 0 ? +(entropy / maxEntropy).toFixed(4) : 0;
+      const entropyLabel = normalizedEntropy > 0.85 ? "high (unpredictable)" : normalizedEntropy > 0.6 ? "moderate" : "low (patterned)";
+
+      // ── Autocorrelation at lags 1-5 ──
+      const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+      const totalVar = returns.reduce((s, r) => s + (r - mean) ** 2, 0);
+      const autocorrelations: number[] = [];
+      for (let lag = 1; lag <= 5; lag++) {
+        let cov = 0;
+        for (let i = lag; i < returns.length; i++) {
+          cov += (returns[i] - mean) * (returns[i - lag] - mean);
+        }
+        autocorrelations.push(totalVar > 0 ? +(cov / totalVar).toFixed(4) : 0);
+      }
+
+      // Overall regime determination
+      let regime: string;
+      if (hurst < 0.4 && vr2 < 0.85) regime = "mean-reverting";
+      else if (hurst > 0.6 && vr2 > 1.15) regime = "trending";
+      else if (normalizedEntropy > 0.85 && Math.abs(vr2 - 1) < 0.15) regime = "efficient (random walk)";
+      else regime = "mixed / transitioning";
+
+      const strategyHint = regime === "mean-reverting" ? "Fade moves, buy dips, sell rallies. Bollinger bands + mean-reversion strategies work well."
+        : regime === "trending" ? "Follow the trend. Momentum strategies, breakout entries. Don't fade."
+        : regime === "efficient (random walk)" ? "Market is efficient — edge comes from information, not price patterns. Focus on news/sentiment."
+        : "Mixed regime — use adaptive strategies or wait for clearer signals.";
+
+      return {
+        title: data.title, slug: args.slug, interval: args.interval ?? "1w",
+        dataPoints: prices.length,
+        regime, strategyHint,
+        hurst: { value: hurst, label: hurstLabel },
+        varianceRatio: { vr2, vr5, vr10, label: vr2 > 1.15 ? "trending" : vr2 < 0.85 ? "mean-reverting" : "efficient" },
+        entropy: { value: +entropy.toFixed(4), normalized: normalizedEntropy, label: entropyLabel },
+        autocorrelations: { lag1: autocorrelations[0], lag2: autocorrelations[1], lag3: autocorrelations[2], lag4: autocorrelations[3], lag5: autocorrelations[4] },
+        priceHistory: prices,
+      };
+    },
+  }),
+
+  // ── Stock market tools (Yahoo Finance — free, no API key) ──
+
+  stockQuote: t({
+    description: "Get real-time stock quotes: price, change, volume, market cap, P/E, 52-week range, moving averages. Supports stocks, ETFs, indices, crypto. No API key needed.",
+    parameters: z.object({
+      symbols: z.string().describe("Comma-separated symbols (e.g. AAPL,MSFT,TSLA or ^SPX,BTC-USD)"),
+    }),
+    execute: async (args: any) => {
+      const symbols = args.symbols.split(",").map((s: string) => s.trim()).filter(Boolean);
+      if (symbols.length === 0) return { error: "No symbols provided" };
+      if (symbols.length > 10) return { error: "Max 10 symbols at once" };
+
+      const quotes = await yahooQuote(symbols);
+      if (quotes.length === 0) return { error: "No results found" };
+
+      return {
+        quotes,
+        summary: quotes.length > 1 ? {
+          avgChange: +(quotes.reduce((s: number, q: any) => s + (q.changePct ?? 0), 0) / quotes.length).toFixed(2),
+          topGainer: quotes.reduce((best: any, q: any) => (q.changePct ?? 0) > (best.changePct ?? 0) ? q : best),
+          topLoser: quotes.reduce((worst: any, q: any) => (q.changePct ?? 0) < (worst.changePct ?? 0) ? q : worst),
+        } : undefined,
+      };
+    },
+  }),
+
+  stockChart: t({
+    description: "Get stock price chart with OHLCV data. Renders as sparkline + stats. No API key needed.",
+    parameters: z.object({
+      symbol: z.string().describe("Stock symbol (e.g. AAPL, TSLA, ^SPX, BTC-USD)"),
+      range: z.string().optional().describe("Time range: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, max (default 1mo)"),
+      interval: z.string().optional().describe("Candle interval: 1m, 5m, 15m, 1h, 1d, 1wk, 1mo (default auto)"),
+    }),
+    execute: async (args: any) => {
+      const range = args.range ?? "1mo";
+      // Auto-select interval based on range
+      const intervalMap: Record<string, string> = {
+        "1d": "5m", "5d": "15m", "1mo": "1d", "3mo": "1d",
+        "6mo": "1d", "1y": "1wk", "2y": "1wk", "5y": "1mo", "max": "1mo",
+      };
+      const interval = args.interval ?? intervalMap[range] ?? "1d";
+      return yahooChart(args.symbol, range, interval);
+    },
+  }),
+
+  stockSearch: t({
+    description: "Search for stock tickers by name, company, or keyword. No API key needed.",
+    parameters: z.object({
+      query: z.string().describe("Search query (e.g. 'Apple', 'electric vehicle', 'gold ETF')"),
+    }),
+    execute: async (args: any) => {
+      const results = await yahooSearch(args.query);
+      return { query: args.query, results };
+    },
+  }),
+
+  stockScreener: t({
+    description: "Compare multiple stocks side-by-side: prices, P/E, market cap, 52-week ranges, moving averages. Great for sector analysis.",
+    parameters: z.object({
+      symbols: z.string().describe("Comma-separated symbols (e.g. AAPL,MSFT,GOOG,AMZN,META)"),
+    }),
+    execute: async (args: any) => {
+      const symbols = args.symbols.split(",").map((s: string) => s.trim()).filter(Boolean).slice(0, 10);
+      const quotes = await yahooQuote(symbols);
+
+      return {
+        stocks: quotes.map((q: any) => ({
+          symbol: q.symbol, name: q.name, price: q.price,
+          change: q.change, changePct: q.changePct,
+          marketCap: q.marketCap, peRatio: q.peRatio,
+          volume: q.volume, avgVolume: q.avgVolume,
+          fiftyTwoWeekHigh: q.fiftyTwoWeekHigh,
+          fiftyTwoWeekLow: q.fiftyTwoWeekLow,
+          fiftyDayAvg: q.fiftyDayAvg,
+          twoHundredDayAvg: q.twoHundredDayAvg,
+          beta: q.beta, dividendYield: q.dividendYield,
+          distFromHigh: q.fiftyTwoWeekHigh ? +((q.price - q.fiftyTwoWeekHigh) / q.fiftyTwoWeekHigh * 100).toFixed(1) : null,
+          aboveFiftyDayMA: q.fiftyDayAvg ? q.price > q.fiftyDayAvg : null,
+          aboveTwoHundredDayMA: q.twoHundredDayAvg ? q.price > q.twoHundredDayAvg : null,
+        })),
+      };
+    },
+  }),
+
+  // ── Browser chart plotting ──
+
+  openChart: t({
+    description: "Open an interactive Chart.js chart in the browser. Works for both prediction markets (by slug) and stocks (by symbol). Shows candlesticks, volume, and moving averages.",
+    parameters: z.object({
+      source: z.enum(["polymarket", "stock"]).describe("Data source: polymarket or stock"),
+      identifier: z.string().describe("Market slug (polymarket) or stock symbol (stock)"),
+      range: z.string().optional().describe("Time range (default: 1mo for stocks, 1w for prediction markets)"),
+      title: z.string().optional().describe("Custom chart title"),
+    }),
+    execute: async (args: any) => {
+      let labels: string[] = [];
+      let prices: number[] = [];
+      let volumes: number[] = [];
+      let chartTitle = args.title ?? args.identifier;
+
+      if (args.source === "stock") {
+        const range = args.range ?? "1mo";
+        const intervalMap: Record<string, string> = {
+          "1d": "5m", "5d": "15m", "1mo": "1d", "3mo": "1d",
+          "6mo": "1d", "1y": "1wk", "2y": "1wk", "5y": "1mo", "max": "1mo",
+        };
+        const interval = intervalMap[range] ?? "1d";
+        const data = await yahooChart(args.identifier, range, interval);
+        chartTitle = `${data.symbol} — ${data.name} (${range})`;
+        for (const p of data.priceHistory) {
+          if (p.p != null) {
+            labels.push(new Date(p.t * 1000).toLocaleDateString());
+            prices.push(+p.p.toFixed(2));
+            volumes.push(p.v ?? 0);
+          }
+        }
+      } else {
+        const range = args.range ?? "1w";
+        const data = await clobPriceHistory(args.identifier, range, 60);
+        chartTitle = `${data.title} (${range})`;
+        for (const p of data.priceHistory) {
+          labels.push(new Date(p.t * 1000).toLocaleString());
+          prices.push(+p.p.toFixed(4));
+        }
+      }
+
+      if (prices.length === 0) return { error: "No data to chart" };
+
+      // Compute 20-period SMA
+      const sma: (number | null)[] = [];
+      for (let i = 0; i < prices.length; i++) {
+        if (i < 19) { sma.push(null); continue; }
+        const window = prices.slice(i - 19, i + 1);
+        sma.push(+(window.reduce((a, b) => a + b, 0) / 20).toFixed(4));
+      }
+
+      const html = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${chartTitle}</title>
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+<style>
+body{margin:0;padding:20px;background:#0d1117;color:#c9d1d9;font-family:system-ui}
+h2{text-align:center;font-weight:400;color:#58a6ff}
+.container{max-width:1200px;margin:0 auto}
+canvas{background:#161b22;border-radius:8px}
+</style></head><body>
+<div class="container">
+<h2>${chartTitle}</h2>
+<canvas id="price" height="300"></canvas>
+${volumes.length > 0 ? '<canvas id="vol" height="100" style="margin-top:12px"></canvas>' : ''}
+</div>
+<script>
+const labels=${JSON.stringify(labels)};
+const prices=${JSON.stringify(prices)};
+const sma=${JSON.stringify(sma)};
+const volumes=${JSON.stringify(volumes)};
+new Chart(document.getElementById('price'),{type:'line',data:{labels,datasets:[
+{label:'Price',data:prices,borderColor:'#58a6ff',backgroundColor:'rgba(88,166,255,0.1)',fill:true,tension:0.1,pointRadius:0,borderWidth:2},
+{label:'SMA(20)',data:sma,borderColor:'#f0883e',borderDash:[5,5],pointRadius:0,borderWidth:1.5}
+]},options:{animation:false,responsive:true,scales:{x:{display:true,ticks:{color:'#484f58',maxTicksLimit:12}},y:{display:true,ticks:{color:'#484f58'}}},plugins:{legend:{labels:{color:'#c9d1d9'}}}}});
+${volumes.length > 0 ? `new Chart(document.getElementById('vol'),{type:'bar',data:{labels,datasets:[{label:'Volume',data:volumes,backgroundColor:'rgba(88,166,255,0.3)',borderWidth:0}]},options:{animation:false,responsive:true,scales:{x:{display:false},y:{ticks:{color:'#484f58'}}},plugins:{legend:{display:false}}}});` : ''}
+</script></body></html>`;
+
+      // Write to temp file and open
+      const tmpDir = `${process.env.HOME ?? "/tmp"}/.horizon/charts`;
+      const fs = require("fs");
+      fs.mkdirSync(tmpDir, { recursive: true });
+      const filename = `chart-${Date.now()}.html`;
+      const filepath = `${tmpDir}/${filename}`;
+      fs.writeFileSync(filepath, html);
+
+      // Open in browser
+      const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+      Bun.spawn([openCmd, filepath], { stdout: "ignore", stderr: "ignore" });
+
+      return {
+        opened: true,
+        path: filepath,
+        title: chartTitle,
+        dataPoints: prices.length,
+        hint: "Chart opened in your browser. Data includes price line + 20-period SMA.",
+      };
+    },
+  }),
 };