@agenticmail/enterprise 0.5.441 → 0.5.443

package/dist/chunk-IN7VIORK.js

@@ -0,0 +1,2641 @@
+import {
+  screenMarkets
+} from "./chunk-ZMKVEJKR.js";
+import {
+  CLOB_API,
+  CTF_ADDRESS,
+  GAMMA_API,
+  NEGATIVE_WORDS,
+  POSITIVE_WORDS,
+  USDC_ADDRESS,
+  apiFetch,
+  cachedFetchJSON,
+  cachedFetchText,
+  calculateHurst,
+  calculateVolatility,
+  ewma,
+  extractTopics,
+  fetchPriceHistory,
+  fetchPriceSeries,
+  linearRegression,
+  normalCDF,
+  normalInv,
+  normalPDF,
+  parseRSSItems,
+  pearsonCorrelation,
+  scoreSentiment,
+  sma,
+  std
+} from "./chunk-CVFIM72Q.js";
+
+// src/polymarket-engines/quant.ts
+async function calculateKelly(params) {
+  let price = params.market_price;
+  if (!price && params.token_id) {
+    const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`);
+    price = parseFloat(mid?.mid || "0.5");
+  }
+  if (!price) throw new Error("Provide market_price or token_id");
+  const prob = params.true_probability;
+  const q = 1 - prob;
+  const b = 1 / price - 1;
+  const kellyFraction = (prob * b - q) / b;
+  const halfKelly = kellyFraction / 2;
+  const quarterKelly = kellyFraction / 4;
+  const maxF = params.max_fraction || 0.25;
+  const cappedKelly = Math.min(Math.max(kellyFraction, 0), maxF);
+  const ev = prob * (1 / price - 1) - q;
+  const bankroll = params.bankroll || 0;
+  const optimalBet = bankroll * cappedKelly;
+  return {
+    formula: "f* = (p\xB7b - q) / b",
+    inputs: { true_probability: prob, market_price: price, odds: b.toFixed(4) },
+    kelly: {
+      full: parseFloat(kellyFraction.toFixed(6)),
+      half: parseFloat(halfKelly.toFixed(6)),
+      quarter: parseFloat(quarterKelly.toFixed(6)),
+      capped: parseFloat(cappedKelly.toFixed(6))
+    },
+    expected_value_per_dollar: parseFloat(ev.toFixed(6)),
+    edge_pct: parseFloat(((prob - price) * 100).toFixed(2)),
+    signal: kellyFraction > 0 ? "BUY" : kellyFraction < -0.01 ? "SELL" : "NO_EDGE",
+    recommended_bet: bankroll > 0 ? {
+      full_kelly: parseFloat((bankroll * Math.max(kellyFraction, 0)).toFixed(2)),
+      half_kelly: parseFloat((bankroll * Math.max(halfKelly, 0)).toFixed(2)),
+      quarter_kelly: parseFloat((bankroll * Math.max(quarterKelly, 0)).toFixed(2)),
+      capped: parseFloat(optimalBet.toFixed(2))
+    } : void 0,
+    warnings: [
+      kellyFraction > 0.5 ? "WARNING: Full Kelly > 50% \u2014 extremely aggressive, use half or quarter Kelly" : "",
+      kellyFraction <= 0 ? "No edge detected at this price \u2014 do not bet" : "",
+      Math.abs(prob - price) < 0.02 ? "Edge is very thin (<2%) \u2014 transaction costs may eliminate profit" : ""
+    ].filter(Boolean)
+  };
+}
+async function priceBinaryOption(params) {
+  let price = params.current_price;
+  let vol = params.volatility;
+  if (!price && params.token_id) {
+    const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`);
+    price = parseFloat(mid?.mid || "0.5");
+  }
+  if (!price) throw new Error("Provide current_price or token_id");
+  let T;
+  if (params.time_to_expiry_hours) {
+    T = params.time_to_expiry_hours / 8760;
+  } else if (params.end_date) {
+    T = Math.max(0, (new Date(params.end_date).getTime() - Date.now()) / (8760 * 36e5));
+  } else {
+    throw new Error("Provide time_to_expiry_hours or end_date");
+  }
+  if (!vol && params.token_id) {
+    const prices = await fetchPriceSeries(params.token_id, 100);
+    if (prices.length > 10) {
+      const returns = prices.slice(1).map((pr, i) => Math.log(pr / prices[i]));
+      vol = std(returns) * Math.sqrt(365 * 24);
+    }
+  }
+  vol = vol || 1;
+  const clampedPrice = Math.max(0.01, Math.min(0.99, price));
+  const logOdds = Math.log(clampedPrice / (1 - clampedPrice));
+  const sqrtT = Math.sqrt(T);
+  const d1 = (logOdds + 0.5 * vol * vol * T) / (vol * sqrtT || 1);
+  const d2 = d1 - vol * sqrtT;
+  const theoreticalPrice = normalCDF(d2);
+  const delta = normalPDF(d2) / (vol * sqrtT * clampedPrice * (1 - clampedPrice) || 1);
+  const gamma = normalPDF(d2) * d1 / (vol * sqrtT * clampedPrice * clampedPrice * (1 - clampedPrice) * (1 - clampedPrice) || 1);
+  const theta = -normalPDF(d2) * vol / (2 * sqrtT || 1) / 8760;
+  const vega = normalPDF(d2) * sqrtT * 0.01;
+  const mispricing = params.true_probability ? {
+    your_estimate: params.true_probability,
+    market_price: price,
+    theoretical_price: parseFloat(theoreticalPrice.toFixed(4)),
+    edge: parseFloat(((params.true_probability - price) * 100).toFixed(2)) + "%",
+    signal: params.true_probability > price + 0.03 ? "BUY" : params.true_probability < price - 0.03 ? "SELL" : "FAIR"
+  } : void 0;
+  return {
+    model: "Binary Option (Black-Scholes Analog)",
+    inputs: { price, volatility: parseFloat(vol.toFixed(4)), time_to_expiry_years: parseFloat(T.toFixed(6)), time_to_expiry_hours: parseFloat((T * 8760).toFixed(1)) },
+    theoretical_price: parseFloat(theoreticalPrice.toFixed(4)),
+    market_price: price,
+    difference: parseFloat((theoreticalPrice - price).toFixed(4)),
+    greeks: {
+      delta: parseFloat(delta.toFixed(6)),
+      gamma: parseFloat(gamma.toFixed(6)),
+      theta_per_hour: parseFloat(theta.toFixed(8)),
+      theta_per_day: parseFloat((theta * 24).toFixed(6)),
+      vega: parseFloat(vega.toFixed(6))
+    },
+    interpretation: {
+      delta: `Price moves ~${(Math.abs(delta) * 100).toFixed(1)}\xA2 per 1% true probability change`,
+      gamma: gamma > 0.5 ? "HIGH \u2014 price very sensitive near 50/50" : "MODERATE",
+      theta: `Losing ${(Math.abs(theta) * 24 * 100).toFixed(3)}\xA2/day to time decay`,
+      time_premium: parseFloat(((price - (price > 0.5 ? 1 : 0)) * (price > 0.5 ? -1 : 1)).toFixed(4))
+    },
+    mispricing
+  };
+}
+async function bayesianUpdate(params) {
+  let prior = params.prior;
+  if (!prior && params.token_id) {
+    const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`);
+    prior = parseFloat(mid?.mid || "0.5");
+  }
+  prior = prior || 0.5;
+  const updates = [];
+  let current = prior;
+  for (const ev of params.evidence || []) {
+    const prevProb = current;
+    let lr;
+    if (ev.likelihood_ratio) {
+      lr = ev.likelihood_ratio;
+    } else if (ev.likelihood_if_true !== void 0 && ev.likelihood_if_false !== void 0) {
+      lr = ev.likelihood_if_true / (ev.likelihood_if_false || 1e-3);
+    } else {
+      continue;
+    }
+    const priorOdds = current / (1 - current);
+    const posteriorOdds = lr * priorOdds;
+    current = posteriorOdds / (1 + posteriorOdds);
+    current = Math.max(1e-3, Math.min(0.999, current));
+    updates.push({
+      evidence: ev.description || "unnamed",
+      likelihood_ratio: parseFloat(lr.toFixed(4)),
+      log_lr: parseFloat(Math.log2(lr).toFixed(4)),
+      prior: parseFloat(prevProb.toFixed(4)),
+      posterior: parseFloat(current.toFixed(4)),
+      shift: parseFloat(((current - prevProb) * 100).toFixed(2)) + "%",
+      bits_of_evidence: parseFloat(Math.abs(Math.log2(lr)).toFixed(2))
+    });
+  }
+  const totalShift = current - prior;
+  const marketPrice = params.token_id ? parseFloat((await apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`).catch(() => ({ mid: prior }))).mid || String(prior)) : prior;
+  return {
+    formula: "P(H|E) = LR \xB7 P(H) / [LR \xB7 P(H) + P(\xACH)]",
+    initial_prior: parseFloat(prior.toFixed(4)),
+    final_posterior: parseFloat(current.toFixed(4)),
+    total_shift: parseFloat((totalShift * 100).toFixed(2)) + "%",
+    total_log_odds_shift: parseFloat((Math.log(current / (1 - current)) - Math.log(prior / (1 - prior))).toFixed(4)),
+    updates,
+    market_comparison: {
+      market_price: parseFloat(marketPrice.toFixed(4)),
+      your_posterior: parseFloat(current.toFixed(4)),
+      edge: parseFloat(((current - marketPrice) * 100).toFixed(2)) + "%",
+      signal: current > marketPrice + 0.03 ? "BUY" : current < marketPrice - 0.03 ? "SELL" : "FAIR"
+    }
+  };
+}
+async function runMonteCarlo(params) {
+  const N = Math.min(params.simulations || 1e4, 1e5);
+  const T = (params.time_horizon_hours || 24) / 8760;
+  const vol = params.volatility || 1;
+  const corr = params.correlation || 0;
+  const positions = params.positions || [];
+  if (positions.length === 0) throw new Error("No positions provided");
+  for (const pos of positions) {
+    if (pos.token_id && !pos.current_price) {
+      try {
+        const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${pos.token_id}`);
+        pos.current_price = parseFloat(mid?.mid || String(pos.entry_price || 0.5));
+      } catch {
+        pos.current_price = pos.entry_price || 0.5;
+      }
+    }
+  }
+  const pnlDistribution = [];
+  const sqrtT = Math.sqrt(T);
+  for (let sim = 0; sim < N; sim++) {
+    let totalPnl = 0;
+    const z1 = normalInv(Math.random());
+    for (const pos of positions) {
+      const z2 = normalInv(Math.random());
+      const z = corr * z1 + Math.sqrt(1 - corr * corr) * z2;
+      const currentP = pos.current_price || 0.5;
+      const trueP = pos.true_probability || currentP;
+      const meanReversion = 0.5;
+      const logOdds = Math.log(currentP / (1 - currentP));
+      const targetLogOdds = Math.log(trueP / (1 - trueP));
+      const newLogOdds = logOdds + meanReversion * (targetLogOdds - logOdds) * T + vol * sqrtT * z;
+      let simPrice = 1 / (1 + Math.exp(-newLogOdds));
+      simPrice = Math.max(0.01, Math.min(0.99, simPrice));
+      const entryPrice = pos.entry_price || currentP;
+      const size = pos.size || 1;
+      const pnl = pos.side === "BUY" ? (simPrice - entryPrice) * size : (entryPrice - simPrice) * size;
+      totalPnl += pnl;
+    }
+    pnlDistribution.push(totalPnl);
+  }
+  pnlDistribution.sort((a, b) => a - b);
+  const mean = pnlDistribution.reduce((s, v) => s + v, 0) / N;
+  const stdDev = std(pnlDistribution);
+  const profitCount = pnlDistribution.filter((v) => v > 0).length;
+  const pctl = (pct) => pnlDistribution[Math.floor(N * pct / 100)];
+  return {
+    model: "Mean-Reverting Geometric Brownian Motion (Ornstein-Uhlenbeck)",
+    simulations: N,
+    time_horizon_hours: params.time_horizon_hours || 24,
+    positions: positions.length,
+    results: {
+      expected_pnl: parseFloat(mean.toFixed(2)),
+      std_dev: parseFloat(stdDev.toFixed(2)),
+      probability_of_profit: parseFloat((profitCount / N * 100).toFixed(1)) + "%",
+      sharpe_ratio: stdDev > 0 ? parseFloat((mean / stdDev).toFixed(3)) : null
+    },
+    risk_metrics: {
+      var_95: parseFloat(pctl(5).toFixed(2)),
+      var_99: parseFloat(pctl(1).toFixed(2)),
+      cvar_95: parseFloat((pnlDistribution.slice(0, Math.floor(N * 0.05)).reduce((s, v) => s + v, 0) / Math.floor(N * 0.05)).toFixed(2)),
+      max_loss: parseFloat(pnlDistribution[0].toFixed(2)),
+      max_gain: parseFloat(pnlDistribution[N - 1].toFixed(2))
+    },
+    distribution: {
+      p1: parseFloat(pctl(1).toFixed(2)),
+      p5: parseFloat(pctl(5).toFixed(2)),
+      p10: parseFloat(pctl(10).toFixed(2)),
+      p25: parseFloat(pctl(25).toFixed(2)),
+      p50: parseFloat(pctl(50).toFixed(2)),
+      p75: parseFloat(pctl(75).toFixed(2)),
+      p90: parseFloat(pctl(90).toFixed(2)),
+      p95: parseFloat(pctl(95).toFixed(2)),
+      p99: parseFloat(pctl(99).toFixed(2))
+    }
+  };
+}
+async function calculateTechnicalIndicators(params) {
+  let prices = params.prices;
+  if (!prices && params.token_id) {
+    prices = await fetchPriceSeries(params.token_id, 200);
+  }
+  if (!prices || prices.length < 15) throw new Error("Need at least 15 price points");
+  const indicators = params.indicators || ["all"];
+  const doAll = indicators.includes("all");
+  const result = { data_points: prices.length, latest_price: prices[prices.length - 1] };
+  if (doAll || indicators.includes("rsi")) {
+    const period = params.rsi_period || 14;
+    const gains = [], losses = [];
+    for (let i = 1; i < prices.length; i++) {
+      const change = prices[i] - prices[i - 1];
+      gains.push(change > 0 ? change : 0);
+      losses.push(change < 0 ? -change : 0);
+    }
+    let avgGain = gains.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    for (let i = period; i < gains.length; i++) {
+      avgGain = (avgGain * (period - 1) + gains[i]) / period;
+      avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    }
+    const rs = avgLoss > 0 ? avgGain / avgLoss : 100;
+    const rsi = 100 - 100 / (1 + rs);
+    result.rsi = {
+      value: parseFloat(rsi.toFixed(2)),
+      period,
+      signal: rsi > 70 ? "OVERBOUGHT" : rsi < 30 ? "OVERSOLD" : "NEUTRAL",
+      interpretation: rsi > 70 ? "Price may be overextended \u2014 consider selling" : rsi < 30 ? "Price may be undervalued \u2014 consider buying" : "No extreme detected"
+    };
+  }
+  if (doAll || indicators.includes("macd")) {
+    const fast = ewma(prices, params.macd_fast || 12);
+    const slow = ewma(prices, params.macd_slow || 26);
+    const macdLine = fast.map((f, i) => f - slow[i]);
+    const signalLine = ewma(macdLine, params.macd_signal || 9);
+    const histogram = macdLine.map((m, i) => m - signalLine[i]);
+    const latestMacd = macdLine[macdLine.length - 1];
+    const latestSignal = signalLine[signalLine.length - 1];
+    const latestHist = histogram[histogram.length - 1];
+    const prevHist = histogram[histogram.length - 2];
+    result.macd = {
+      macd_line: parseFloat(latestMacd.toFixed(6)),
+      signal_line: parseFloat(latestSignal.toFixed(6)),
+      histogram: parseFloat(latestHist.toFixed(6)),
+      signal: latestMacd > latestSignal ? "BULLISH" : "BEARISH",
+      crossover: latestHist > 0 && prevHist <= 0 ? "BULLISH_CROSS" : latestHist < 0 && prevHist >= 0 ? "BEARISH_CROSS" : "NONE",
+      momentum: latestHist > prevHist ? "INCREASING" : "DECREASING"
+    };
+  }
+  if (doAll || indicators.includes("bollinger")) {
+    const period = params.bollinger_period || 20;
+    const numStd = params.bollinger_std || 2;
+    const ma = sma(prices, period);
+    const latestMa = ma[ma.length - 1];
+    const recentPrices = prices.slice(-period);
+    const stdDev = std(recentPrices);
+    const upper = latestMa + numStd * stdDev;
+    const lower = latestMa - numStd * stdDev;
+    const currentPrice = prices[prices.length - 1];
+    const bandwidth = (upper - lower) / latestMa;
+    const pctB = (currentPrice - lower) / (upper - lower);
+    result.bollinger = {
+      upper: parseFloat(upper.toFixed(4)),
+      middle: parseFloat(latestMa.toFixed(4)),
+      lower: parseFloat(lower.toFixed(4)),
+      bandwidth: parseFloat(bandwidth.toFixed(4)),
+      percent_b: parseFloat(pctB.toFixed(4)),
+      signal: pctB > 1 ? "ABOVE_UPPER (overbought)" : pctB < 0 ? "BELOW_LOWER (oversold)" : bandwidth < 0.05 ? "SQUEEZE (breakout imminent)" : "WITHIN_BANDS"
+    };
+  }
+  if (doAll || indicators.includes("ema")) {
+    const ema9 = ewma(prices, 9);
+    const ema21 = ewma(prices, 21);
+    const ema50 = ewma(prices, Math.min(50, prices.length));
+    const latest9 = ema9[ema9.length - 1];
+    const latest21 = ema21[ema21.length - 1];
+    const latest50 = ema50[ema50.length - 1];
+    result.ema = {
+      ema_9: parseFloat(latest9.toFixed(4)),
+      ema_21: parseFloat(latest21.toFixed(4)),
+      ema_50: parseFloat(latest50.toFixed(4)),
+      trend: latest9 > latest21 && latest21 > latest50 ? "STRONG_UPTREND" : latest9 < latest21 && latest21 < latest50 ? "STRONG_DOWNTREND" : latest9 > latest21 ? "MILD_UPTREND" : "MILD_DOWNTREND",
+      golden_cross: latest9 > latest50 && ema9[ema9.length - 2] <= ema50[ema50.length - 2],
+      death_cross: latest9 < latest50 && ema9[ema9.length - 2] >= ema50[ema50.length - 2]
+    };
+  }
+  if (doAll || indicators.includes("momentum")) {
+    const roc5 = (prices[prices.length - 1] - prices[prices.length - 6]) / prices[prices.length - 6] * 100;
+    const roc10 = prices.length > 10 ? (prices[prices.length - 1] - prices[prices.length - 11]) / prices[prices.length - 11] * 100 : null;
+    const roc20 = prices.length > 20 ? (prices[prices.length - 1] - prices[prices.length - 21]) / prices[prices.length - 21] * 100 : null;
+    result.momentum = {
+      roc_5: parseFloat(roc5.toFixed(2)) + "%",
+      roc_10: roc10 !== null ? parseFloat(roc10.toFixed(2)) + "%" : null,
+      roc_20: roc20 !== null ? parseFloat(roc20.toFixed(2)) + "%" : null,
+      acceleration: roc10 !== null ? parseFloat((roc5 - roc10).toFixed(2)) : null
+    };
+  }
+  const signals = [];
+  if (result.rsi?.signal === "OVERSOLD") signals.push("BUY");
+  if (result.rsi?.signal === "OVERBOUGHT") signals.push("SELL");
+  if (result.macd?.signal === "BULLISH") signals.push("BUY");
+  if (result.macd?.signal === "BEARISH") signals.push("SELL");
+  if (result.bollinger?.signal?.includes("oversold")) signals.push("BUY");
+  if (result.bollinger?.signal?.includes("overbought")) signals.push("SELL");
+  if (result.ema?.trend?.includes("UPTREND")) signals.push("BUY");
+  if (result.ema?.trend?.includes("DOWNTREND")) signals.push("SELL");
+  const buyCount = signals.filter((s) => s === "BUY").length;
+  const sellCount = signals.filter((s) => s === "SELL").length;
+  result.composite_signal = {
+    buy_signals: buyCount,
+    sell_signals: sellCount,
+    total_indicators: buyCount + sellCount,
+    consensus: buyCount > sellCount ? "BUY" : sellCount > buyCount ? "SELL" : "MIXED",
+    confidence: buyCount + sellCount > 0 ? parseFloat((Math.abs(buyCount - sellCount) / (buyCount + sellCount) * 100).toFixed(0)) + "%" : "N/A"
+  };
+  return result;
+}
+async function analyzeVolatility(params) {
+  let prices = params.prices;
+  if (!prices && params.token_id) prices = await fetchPriceSeries(params.token_id, 200);
+  if (!prices || prices.length < 20) throw new Error("Need at least 20 price points");
+  const returns = prices.slice(1).map((pr, i) => Math.log(pr / prices[i]));
+  const windows = params.windows || [5, 10, 20, 50];
+  const realizedVol = {};
+  for (const w of windows) {
+    if (returns.length >= w) {
+      const windowReturns = returns.slice(-w);
+      realizedVol[`${w}_period`] = parseFloat((std(windowReturns) * Math.sqrt(365 * 24)).toFixed(4));
+    }
+  }
+  const ewmaVol = ewma(returns.map((r) => r * r), 10).map((v) => Math.sqrt(v * 365 * 24));
+  const latestEwmaVol = ewmaVol[ewmaVol.length - 1];
+  let hurst = 0.5;
+  if (returns.length >= 20) {
+    const logNs = [], logRS = [];
+    for (const n of [5, 10, 15, 20, Math.min(40, Math.floor(returns.length / 2))]) {
+      if (n > returns.length) continue;
+      const chunks = Math.floor(returns.length / n);
+      let totalRS = 0;
+      for (let c = 0; c < chunks; c++) {
+        const chunk = returns.slice(c * n, (c + 1) * n);
+        const mean = chunk.reduce((s, v) => s + v, 0) / n;
+        const deviations = chunk.map((v) => v - mean);
+        const cumDev = [];
+        let sum = 0;
+        for (const d of deviations) {
+          sum += d;
+          cumDev.push(sum);
+        }
+        const R = Math.max(...cumDev) - Math.min(...cumDev);
+        const S = std(chunk);
+        if (S > 0) totalRS += R / S;
+      }
+      if (totalRS > 0 && chunks > 0) {
+        logNs.push(Math.log(n));
+        logRS.push(Math.log(totalRS / chunks));
+      }
+    }
+    if (logNs.length >= 3) {
+      const reg = linearRegression(logNs, logRS);
+      hurst = reg.slope;
+    }
+  }
+  const currentVol = realizedVol["10_period"] || latestEwmaVol;
+  const longVol = realizedVol["50_period"] || currentVol;
+  return {
+    realized_volatility: realizedVol,
+    ewma_volatility: parseFloat(latestEwmaVol.toFixed(4)),
+    hurst_exponent: {
+      value: parseFloat(hurst.toFixed(4)),
+      interpretation: hurst > 0.6 ? "TRENDING \u2014 momentum strategies may work" : hurst < 0.4 ? "MEAN_REVERTING \u2014 contrarian strategies may work" : "RANDOM_WALK \u2014 market is efficient at this timescale",
+      regime: hurst > 0.6 ? "trending" : hurst < 0.4 ? "mean_reverting" : "random_walk"
+    },
+    volatility_regime: {
+      current_vs_long: parseFloat((currentVol / (longVol || 1)).toFixed(2)),
+      regime: currentVol > longVol * 1.5 ? "HIGH_VOL (elevated risk)" : currentVol < longVol * 0.5 ? "LOW_VOL (compression \u2014 breakout possible)" : "NORMAL"
+    },
+    data_points: prices.length
+  };
+}
+async function analyzeStatArb(params) {
+  const [prices1, prices2] = await Promise.all([
+    fetchPriceSeries(params.token_id_1, 200),
+    fetchPriceSeries(params.token_id_2, 200)
+  ]);
+  const len = Math.min(prices1.length, prices2.length);
+  if (len < 20) throw new Error("Need at least 20 data points for both tokens");
+  const p1 = prices1.slice(-len);
+  const p2 = prices2.slice(-len);
+  const reg = linearRegression(p2, p1);
+  const spread = p1.map((v, i) => v - reg.slope * p2[i] - reg.intercept);
+  const lookback = Math.min(params.lookback || 50, len);
+  const recentSpread = spread.slice(-lookback);
+  const meanSpread = recentSpread.reduce((s, v) => s + v, 0) / lookback;
+  const stdSpread = std(recentSpread);
+  const currentZScore = stdSpread > 0 ? (spread[spread.length - 1] - meanSpread) / stdSpread : 0;
+  const mean1 = p1.reduce((s, v) => s + v, 0) / len;
+  const mean2 = p2.reduce((s, v) => s + v, 0) / len;
+  let cov = 0, var1 = 0, var2 = 0;
+  for (let i = 0; i < len; i++) {
+    cov += (p1[i] - mean1) * (p2[i] - mean2);
+    var1 += (p1[i] - mean1) ** 2;
+    var2 += (p2[i] - mean2) ** 2;
+  }
+  const correlation = Math.sqrt(var1 * var2) > 0 ? cov / Math.sqrt(var1 * var2) : 0;
+  const entryZ = params.entry_zscore || 2;
+  const exitZ = params.exit_zscore || 0.5;
+  return {
+    model: "Pairs Trading / Statistical Arbitrage",
+    pair: { token_1: params.token_id_1, token_2: params.token_id_2 },
+    correlation: parseFloat(correlation.toFixed(4)),
+    cointegration: {
+      hedge_ratio: parseFloat(reg.slope.toFixed(4)),
+      intercept: parseFloat(reg.intercept.toFixed(4)),
+      r_squared: parseFloat(reg.r2.toFixed(4)),
+      is_cointegrated: reg.r2 > 0.5 && Math.abs(correlation) > 0.6
+    },
+    spread: {
+      current: parseFloat(spread[spread.length - 1].toFixed(4)),
+      mean: parseFloat(meanSpread.toFixed(4)),
+      std: parseFloat(stdSpread.toFixed(4)),
+      z_score: parseFloat(currentZScore.toFixed(4))
+    },
+    signal: {
+      action: Math.abs(currentZScore) > entryZ ? currentZScore > 0 ? "SHORT_SPREAD (sell 1, buy 2)" : "LONG_SPREAD (buy 1, sell 2)" : Math.abs(currentZScore) < exitZ ? "CLOSE_POSITION" : "HOLD",
+      strength: Math.abs(currentZScore) > entryZ * 1.5 ? "STRONG" : Math.abs(currentZScore) > entryZ ? "MODERATE" : "WEAK",
+      entry_threshold: entryZ,
+      exit_threshold: exitZ
+    },
+    warnings: [
+      Math.abs(correlation) < 0.3 ? "LOW CORRELATION \u2014 these markets may not be related enough for stat arb" : "",
+      reg.r2 < 0.3 ? "POOR FIT \u2014 hedge ratio may be unreliable" : ""
+    ].filter(Boolean)
+  };
+}
+async function calculateVaR(params) {
+  const confidence = params.confidence || 0.95;
+  const horizon = (params.horizon_hours || 24) / (24 * 365);
+  let portfolioReturns = [];
+  let totalExposure = 0;
+  for (const pos of params.positions || []) {
+    const prices = await fetchPriceSeries(pos.token_id, 100);
+    if (prices.length < 10) continue;
+    const returns = prices.slice(1).map((pr, i) => Math.log(pr / prices[i]));
+    const scaledReturns = returns.map((r) => r * (pos.size || 1) * (pos.side === "SELL" ? -1 : 1));
+    if (portfolioReturns.length === 0) {
+      portfolioReturns = scaledReturns;
+    } else {
+      const len = Math.min(portfolioReturns.length, scaledReturns.length);
+      portfolioReturns = portfolioReturns.slice(-len).map((r, i) => r + scaledReturns.slice(-len)[i]);
+    }
+    totalExposure += pos.size || 1;
+  }
+  if (portfolioReturns.length < 10) throw new Error("Insufficient data for VaR calculation");
+  const mean = portfolioReturns.reduce((s, v) => s + v, 0) / portfolioReturns.length;
+  const sigma = std(portfolioReturns);
+  const sqrtH = Math.sqrt(horizon * 365 * 24);
+  const results = { confidence, horizon_hours: params.horizon_hours || 24, total_exposure: totalExposure, data_points: portfolioReturns.length };
+  const method = params.method || "all";
+  if (method === "all" || method === "parametric") {
+    const z = normalInv(1 - confidence);
+    results.parametric = {
+      var: parseFloat((-(mean * sqrtH + z * sigma * sqrtH)).toFixed(2)),
+      note: "Assumes normal distribution of returns"
+    };
+  }
+  if (method === "all" || method === "historical") {
+    const sorted = [...portfolioReturns].sort((a, b) => a - b);
+    const idx = Math.floor(sorted.length * (1 - confidence));
+    const var_ = -sorted[idx] * sqrtH;
+    const cvar = -(sorted.slice(0, idx + 1).reduce((s, v) => s + v, 0) / (idx + 1)) * sqrtH;
+    results.historical = {
+      var: parseFloat(var_.toFixed(2)),
+      cvar_expected_shortfall: parseFloat(cvar.toFixed(2)),
+      note: "Based on actual return distribution"
+    };
+  }
+  if (method === "all" || method === "cornish_fisher") {
+    const n = portfolioReturns.length;
+    const skew = portfolioReturns.reduce((s, r) => s + Math.pow((r - mean) / sigma, 3), 0) / n;
+    const kurt = portfolioReturns.reduce((s, r) => s + Math.pow((r - mean) / sigma, 4), 0) / n - 3;
+    const z = normalInv(1 - confidence);
+    const zCF = z + (z * z - 1) * skew / 6 + (z * z * z - 3 * z) * kurt / 24 - (2 * z * z * z - 5 * z) * skew * skew / 36;
+    results.cornish_fisher = {
+      var: parseFloat((-(mean * sqrtH + zCF * sigma * sqrtH)).toFixed(2)),
+      skewness: parseFloat(skew.toFixed(4)),
+      excess_kurtosis: parseFloat(kurt.toFixed(4)),
+      note: "Adjusts for fat tails and asymmetry in return distribution"
+    };
+  }
+  return results;
+}
+async function calculateEntropy(params) {
+  let probs = params.market_prices;
+  if (!probs && params.token_id) {
+    const mid = await apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`);
+    const pr = parseFloat(mid?.mid || "0.5");
+    probs = [pr, 1 - pr];
+  }
+  if (!probs) throw new Error("Provide market_prices or token_id");
+  const entropy = -probs.reduce((s, p) => {
+    if (p <= 0 || p >= 1) return s;
+    return s + p * Math.log2(p);
+  }, 0);
+  const maxEntropy = Math.log2(probs.length);
+  const normalizedEntropy = maxEntropy > 0 ? entropy / maxEntropy : 0;
+  const result = {
+    shannon_entropy: parseFloat(entropy.toFixed(4)),
+    max_entropy: parseFloat(maxEntropy.toFixed(4)),
+    normalized_entropy: parseFloat(normalizedEntropy.toFixed(4)),
+    interpretation: normalizedEntropy > 0.9 ? "MAXIMUM UNCERTAINTY \u2014 market has no conviction" : normalizedEntropy > 0.7 ? "HIGH UNCERTAINTY \u2014 wide range of outcomes" : normalizedEntropy > 0.3 ? "MODERATE \u2014 some conviction forming" : "DECISIVE \u2014 market strongly favors one outcome",
+    bits_to_resolve: parseFloat(entropy.toFixed(4))
+  };
+  if (params.your_estimates) {
+    const q = params.your_estimates;
+    const klDiv = probs.reduce((s, pi, i) => {
+      if (q[i] <= 0 || pi <= 0) return s;
+      return s + q[i] * Math.log2(q[i] / pi);
+    }, 0);
+    result.kl_divergence = {
+      value: parseFloat(klDiv.toFixed(6)),
+      interpretation: klDiv > 0.5 ? "LARGE DISAGREEMENT \u2014 strong potential edge" : klDiv > 0.1 ? "MODERATE DISAGREEMENT" : "SMALL DISAGREEMENT \u2014 little edge",
+      direction: "Your beliefs diverge from market by " + klDiv.toFixed(4) + " bits"
+    };
+  }
+  return result;
+}
+function analyzeSentiment(texts) {
+  if (texts.length === 0) throw new Error("No texts provided");
+  const analyzed = texts.map((text) => {
+    const words = text.toLowerCase().split(/\s+/);
+    let score = 0, posCount = 0, negCount = 0;
+    for (const w of words) {
+      const clean = w.replace(/[^a-z]/g, "");
+      if (POSITIVE_WORDS[clean]) {
+        score += POSITIVE_WORDS[clean];
+        posCount++;
+      }
+      if (NEGATIVE_WORDS[clean]) {
+        score += NEGATIVE_WORDS[clean];
+        negCount++;
+      }
+    }
+    const normalized = words.length > 0 ? score / Math.sqrt(words.length) : 0;
+    return {
+      text: text.slice(0, 200),
+      raw_score: score,
+      normalized_score: parseFloat(normalized.toFixed(3)),
+      sentiment: normalized > 0.5 ? "POSITIVE" : normalized < -0.5 ? "NEGATIVE" : "NEUTRAL",
+      positive_words: posCount,
+      negative_words: negCount
+    };
+  });
+  const avgScore = analyzed.reduce((s, a) => s + a.normalized_score, 0) / analyzed.length;
+  const posTexts = analyzed.filter((a) => a.sentiment === "POSITIVE").length;
+  const negTexts = analyzed.filter((a) => a.sentiment === "NEGATIVE").length;
+  return {
+    total_texts: texts.length,
+    aggregate: {
+      average_score: parseFloat(avgScore.toFixed(3)),
+      overall_sentiment: avgScore > 0.3 ? "BULLISH" : avgScore < -0.3 ? "BEARISH" : "MIXED",
+      positive_count: posTexts,
+      negative_count: negTexts,
+      neutral_count: texts.length - posTexts - negTexts,
+      consensus_strength: parseFloat((Math.abs(posTexts - negTexts) / texts.length * 100).toFixed(1)) + "%"
+    },
+    details: analyzed.slice(0, 30),
+    market_signal: {
+      direction: avgScore > 0.3 ? "BUY" : avgScore < -0.3 ? "SELL" : "HOLD",
+      confidence: Math.abs(avgScore) > 1 ? "HIGH" : Math.abs(avgScore) > 0.5 ? "MEDIUM" : "LOW"
+    }
+  };
+}
+async function fetchNewsFeed(params) {
+  let query = params.query;
+  if (!query && params.market_id) {
+    const m = await apiFetch(`${GAMMA_API}/markets/${params.market_id}`).catch(() => null);
+    query = m?.question;
+  }
+  if (!query) throw new Error("Provide query or market_id");
+  const googleNewsUrl = `https://news.google.com/rss/search?q=${encodeURIComponent(query)}&hl=en-US&gl=US&ceid=US:en`;
+  try {
+    const rssXml = await cachedFetchText(googleNewsUrl, 15e3);
+    const items = [];
+    const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+    let match;
+    while ((match = itemRegex.exec(typeof rssXml === "string" ? rssXml : "")) !== null) {
+      const get = (tag) => {
+        const m2 = match[1].match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+        return m2 ? m2[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : "";
+      };
+      const title = get("title");
+      const link = get("link");
+      const pubDate = get("pubDate");
+      const source = get("source");
+      if (title) {
+        if (pubDate && params.hours) {
+          const articleDate = new Date(pubDate);
+          const cutoff = new Date(Date.now() - (params.hours || 24) * 36e5);
+          if (articleDate < cutoff) continue;
+        }
+        items.push({
+          title,
+          link,
+          published: pubDate,
+          source: source || "Google News",
+          impact_score: title.toLowerCase().includes("breaking") || title.toLowerCase().includes("urgent") ? "HIGH" : title.toLowerCase().includes("update") || title.toLowerCase().includes("report") ? "MEDIUM" : "STANDARD"
+        });
+      }
+      if (items.length >= (params.limit || 20)) break;
+    }
+    return { query, source: "Google News RSS", articles: items.length, results: items, note: "For deeper analysis, use analyzeSentiment on individual articles." };
+  } catch {
+    return { query, source: "Google News RSS", articles: 0, results: [], note: "RSS unavailable \u2014 use web_search as fallback" };
+  }
+}
+async function generateCompositeSignal(params) {
+  const [midData, bookData, marketData, trades] = await Promise.all([
+    apiFetch(`${CLOB_API}/midpoint?token_id=${params.token_id}`).catch(() => null),
+    apiFetch(`${CLOB_API}/book?token_id=${params.token_id}`).catch(() => null),
+    params.market_id ? apiFetch(`${GAMMA_API}/markets/${params.market_id}`).catch(() => null) : null,
+    apiFetch(`${CLOB_API}/trades?asset_id=${params.token_id}&limit=100`).catch(() => [])
+  ]);
+  const price = parseFloat(midData?.mid || "0.5");
+  const prices = Array.isArray(trades) ? trades.reverse().map((t) => parseFloat(t.price || "0")).filter((v) => v > 0) : [];
+  const signals = [];
+  if (bookData) {
+    const bidVol = (bookData.bids || []).reduce((s, b) => s + parseFloat(b.size || "0") * parseFloat(b.price || "0"), 0);
+    const askVol = (bookData.asks || []).reduce((s, a) => s + parseFloat(a.size || "0") * parseFloat(a.price || "0"), 0);
+    const imbalance = (bidVol - askVol) / (bidVol + askVol || 1);
+    signals.push({
+      name: "Order Book Imbalance",
+      direction: imbalance > 0.2 ? "BUY" : imbalance < -0.2 ? "SELL" : "NEUTRAL",
+      weight: Math.min(Math.abs(imbalance) * 3, 1),
+      detail: `Bid/Ask ratio: ${(bidVol / (askVol || 1)).toFixed(2)}, Imbalance: ${(imbalance * 100).toFixed(1)}%`
+    });
+  }
+  if (prices.length >= 15) {
+    const period = 14;
+    const gains = prices.slice(1).map((pr, i) => Math.max(0, pr - prices[i]));
+    const losses = prices.slice(1).map((pr, i) => Math.max(0, prices[i] - pr));
+    let avgGain = gains.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    for (let i = period; i < gains.length; i++) {
+      avgGain = (avgGain * (period - 1) + gains[i]) / period;
+      avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    }
+    const rsi = 100 - 100 / (1 + (avgLoss > 0 ? avgGain / avgLoss : 100));
+    signals.push({
+      name: "RSI",
+      direction: rsi < 30 ? "BUY" : rsi > 70 ? "SELL" : "NEUTRAL",
+      weight: rsi < 20 || rsi > 80 ? 0.9 : rsi < 30 || rsi > 70 ? 0.6 : 0.2,
+      detail: `RSI(14) = ${rsi.toFixed(1)}`
+    });
+  }
+  if (prices.length >= 10) {
+    const roc = (prices[prices.length - 1] - prices[prices.length - 6]) / prices[prices.length - 6];
+    signals.push({
+      name: "Momentum",
+      direction: roc > 0.03 ? "BUY" : roc < -0.03 ? "SELL" : "NEUTRAL",
+      weight: Math.min(Math.abs(roc) * 10, 1),
+      detail: `5-period ROC: ${(roc * 100).toFixed(1)}%`
+    });
+  }
+  if (prices.length >= 20) {
+    const ma20 = prices.slice(-20).reduce((s, v) => s + v, 0) / 20;
+    const deviation = (price - ma20) / ma20;
+    signals.push({
+      name: "Mean Reversion",
+      direction: deviation < -0.05 ? "BUY" : deviation > 0.05 ? "SELL" : "NEUTRAL",
+      weight: Math.min(Math.abs(deviation) * 5, 1),
+      detail: `Price ${(deviation * 100).toFixed(1)}% from 20-MA (${ma20.toFixed(3)})`
+    });
+  }
+  if (params.true_probability) {
+    const edge = params.true_probability - price;
+    signals.push({
+      name: "Fundamental Edge",
+      direction: edge > 0.02 ? "BUY" : edge < -0.02 ? "SELL" : "NEUTRAL",
+      weight: Math.min(Math.abs(edge) * 10, 1),
+      detail: `Your estimate: ${(params.true_probability * 100).toFixed(1)}%, Market: ${(price * 100).toFixed(1)}%, Edge: ${(edge * 100).toFixed(1)}%`
+    });
+  }
+  if (Array.isArray(trades) && trades.length >= 20) {
+    const recentVol = trades.slice(-10).reduce((s, t) => s + parseFloat(t.size || "0"), 0);
+    const olderVol = trades.slice(-20, -10).reduce((s, t) => s + parseFloat(t.size || "0"), 0);
+    const volChange = olderVol > 0 ? (recentVol - olderVol) / olderVol : 0;
+    const priceDir = prices.length >= 10 ? prices[prices.length - 1] - prices[prices.length - 10] : 0;
+    signals.push({
+      name: "Volume-Price",
+      direction: volChange > 0.3 && priceDir > 0 ? "BUY" : volChange > 0.3 && priceDir < 0 ? "SELL" : "NEUTRAL",
+      weight: Math.min(Math.abs(volChange) * 0.5, 0.7),
+      detail: `Volume ${volChange > 0 ? "+" : ""}${(volChange * 100).toFixed(0)}%, Price ${priceDir > 0 ? "up" : "down"}`
+    });
+  }
+  let buyScore = 0, sellScore = 0, totalWeight = 0;
+  for (const sig of signals) {
+    totalWeight += sig.weight;
+    if (sig.direction === "BUY") buyScore += sig.weight;
+    else if (sig.direction === "SELL") sellScore += sig.weight;
+  }
+  const netScore = totalWeight > 0 ? (buyScore - sellScore) / totalWeight : 0;
+  const confidence = totalWeight > 0 ? Math.abs(buyScore - sellScore) / totalWeight : 0;
+  const direction = netScore > 0.15 ? "BUY" : netScore < -0.15 ? "SELL" : "HOLD";
+  let kellySize = null;
+  if (params.bankroll && direction !== "HOLD") {
+    const trueP = params.true_probability || (direction === "BUY" ? price + confidence * 0.1 : price - confidence * 0.1);
+    const b = 1 / price - 1;
+    const f = (trueP * b - (1 - trueP)) / b;
+    const riskMultiplier = params.risk_tolerance === "conservative" ? 0.25 : params.risk_tolerance === "aggressive" ? 0.75 : 0.5;
+    kellySize = parseFloat((params.bankroll * Math.max(f, 0) * riskMultiplier).toFixed(2));
+  }
+  return {
+    token_id: params.token_id,
+    current_price: price,
+    signal: {
+      direction,
+      confidence: parseFloat((confidence * 100).toFixed(1)) + "%",
+      net_score: parseFloat(netScore.toFixed(3)),
+      buy_weight: parseFloat(buyScore.toFixed(2)),
+      sell_weight: parseFloat(sellScore.toFixed(2))
+    },
+    recommended_position: kellySize !== null ? {
+      size_usdc: kellySize,
+      risk_tolerance: params.risk_tolerance || "moderate",
+      method: "Kelly Criterion (risk-adjusted)"
+    } : void 0,
+    components: signals,
+    warning: confidence < 0.3 ? "LOW CONFIDENCE \u2014 signals are mixed, consider waiting" : void 0
+  };
+}
+async function calculateCorrelationMatrix(params) {
+  const ids = (params.token_ids || []).slice(0, 10);
+  if (ids.length < 2) throw new Error("Need at least 2 token IDs");
+  const allPrices = await Promise.all(ids.map((id) => fetchPriceSeries(id, params.lookback || 50)));
+  const minLen = Math.min(...allPrices.map((pr) => pr.length));
+  if (minLen < 10) throw new Error("Insufficient data points");
+  const aligned = allPrices.map((pr) => pr.slice(-minLen));
+  const returns = aligned.map((pr) => pr.slice(1).map((v, i) => Math.log(v / pr[i])));
+  const n = ids.length;
+  const matrix = Array.from({ length: n }, () => Array(n).fill(0));
+  const labels = params.labels || ids.map((_, i) => `Token ${i + 1}`);
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const len = Math.min(returns[i].length, returns[j].length);
+      const r1 = returns[i].slice(-len), r2 = returns[j].slice(-len);
+      const m1 = r1.reduce((s, v) => s + v, 0) / len;
+      const m2 = r2.reduce((s, v) => s + v, 0) / len;
+      let cv = 0, v1 = 0, v2 = 0;
+      for (let k = 0; k < len; k++) {
+        cv += (r1[k] - m1) * (r2[k] - m2);
+        v1 += (r1[k] - m1) ** 2;
+        v2 += (r2[k] - m2) ** 2;
+      }
+      const corr = Math.sqrt(v1 * v2) > 0 ? cv / Math.sqrt(v1 * v2) : 0;
+      matrix[i][j] = corr;
+      matrix[j][i] = corr;
+    }
+  }
+  const pairs = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      pairs.push({ pair: `${labels[i]} / ${labels[j]}`, correlation: parseFloat(matrix[i][j].toFixed(4)) });
+    }
+  }
+  pairs.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation));
+  return {
+    tokens: ids.length,
+    data_points: minLen,
+    matrix: matrix.map((row, i) => ({
+      token: labels[i],
+      correlations: Object.fromEntries(row.map((v, j) => [labels[j], parseFloat(v.toFixed(4))]))
+    })),
+    most_correlated: pairs[0],
+    least_correlated: pairs[pairs.length - 1],
+    diversification_score: parseFloat((1 - pairs.reduce((s, p) => s + Math.abs(p.correlation), 0) / pairs.length).toFixed(3)),
+    all_pairs: pairs
+  };
+}
+async function testMarketEfficiency(params) {
+  let prices = params.prices;
+  if (!prices && params.token_id) prices = await fetchPriceSeries(params.token_id, 200);
+  if (!prices || prices.length < 30) throw new Error("Need at least 30 data points");
+  const returns = prices.slice(1).map((pr, i) => Math.log(pr / prices[i]));
+  const n = returns.length;
+  const meanR = returns.reduce((s, v) => s + v, 0) / n;
+  const autoCorrs = [];
+  for (let lag = 1; lag <= 5; lag++) {
+    let num = 0, den = 0;
+    for (let i = lag; i < n; i++) num += (returns[i] - meanR) * (returns[i - lag] - meanR);
+    for (let i = 0; i < n; i++) den += (returns[i] - meanR) ** 2;
+    autoCorrs.push(den > 0 ? num / den : 0);
+  }
+  const signs = returns.map((r) => r >= 0 ? 1 : -1);
+  let runs = 1;
+  for (let i = 1; i < signs.length; i++) {
+    if (signs[i] !== signs[i - 1]) runs++;
+  }
+  const nPos = signs.filter((s) => s === 1).length;
+  const nNeg = signs.filter((s) => s === -1).length;
+  const expectedRuns = 1 + 2 * nPos * nNeg / (nPos + nNeg);
+  const stdRuns = Math.sqrt(2 * nPos * nNeg * (2 * nPos * nNeg - nPos - nNeg) / ((nPos + nNeg) ** 2 * (nPos + nNeg - 1)));
+  const runsZ = stdRuns > 0 ? (runs - expectedRuns) / stdRuns : 0;
+  const q = 5;
+  const qReturns = [];
+  for (let i = 0; i <= n - q; i++) {
+    qReturns.push(returns.slice(i, i + q).reduce((s, v) => s + v, 0));
+  }
+  const var1 = returns.reduce((s, r) => s + (r - meanR) ** 2, 0) / (n - 1);
+  const varQ = qReturns.reduce((s, r) => s + (r - q * meanR) ** 2, 0) / (qReturns.length - 1);
+  const vr = varQ / (q * var1);
+  const vrZ = (vr - 1) * Math.sqrt(n * 2 * (2 * q - 1) * (q - 1) / (3 * q));
+  let lbStat = 0;
+  for (let k = 0; k < autoCorrs.length; k++) {
+    lbStat += n * (n + 2) / (n - k - 1) * autoCorrs[k] ** 2;
+  }
+  const isEfficient = Math.abs(runsZ) < 1.96 && Math.abs(vrZ) < 1.96 && lbStat < 11.07;
+  return {
+    data_points: prices.length,
+    autocorrelation: {
+      lag_1: parseFloat(autoCorrs[0].toFixed(4)),
+      lag_2: parseFloat(autoCorrs[1].toFixed(4)),
+      lag_3: parseFloat(autoCorrs[2].toFixed(4)),
+      lag_4: parseFloat(autoCorrs[3].toFixed(4)),
+      lag_5: parseFloat(autoCorrs[4].toFixed(4)),
+      significant: autoCorrs.some((ac) => Math.abs(ac) > 2 / Math.sqrt(n))
+    },
+    runs_test: {
+      runs,
+      expected: parseFloat(expectedRuns.toFixed(1)),
+      z_score: parseFloat(runsZ.toFixed(3)),
+      p_value: parseFloat((2 * (1 - normalCDF(Math.abs(runsZ)))).toFixed(4)),
+      result: Math.abs(runsZ) > 1.96 ? "NON_RANDOM" : "RANDOM"
+    },
+    variance_ratio: {
+      vr: parseFloat(vr.toFixed(4)),
+      z_score: parseFloat(vrZ.toFixed(3)),
+      interpretation: vr > 1.1 ? "MOMENTUM (trending)" : vr < 0.9 ? "MEAN_REVERTING" : "RANDOM_WALK"
+    },
+    ljung_box: {
+      statistic: parseFloat(lbStat.toFixed(2)),
+      significant: lbStat > 11.07
+    },
+    overall: {
+      efficient: isEfficient,
+      exploitable_patterns: !isEfficient,
+      suggested_strategy: !isEfficient ? vr > 1.1 ? "TREND_FOLLOWING \u2014 momentum is persistent" : vr < 0.9 ? "MEAN_REVERSION \u2014 buy dips, sell rallies" : "PATTERN detected but type unclear" : "Market appears efficient \u2014 edge must come from fundamental analysis, not technicals"
+    }
+  };
+}
+
+// src/polymarket-engines/analytics.ts
+async function findCorrelations(tokenIds, minCorrelation = 0.5) {
+  const tokens = tokenIds.slice(0, 10);
+  if (tokens.length < 2) throw new Error("Need at least 2 token IDs");
+  const histories = await Promise.all(tokens.map(async (tid) => ({
+    token_id: tid,
+    prices: await fetchPriceHistory(tid)
+  })));
+  const correlations = [];
+  for (let i = 0; i < histories.length; i++) {
+    for (let j = i + 1; j < histories.length; j++) {
+      const corr = pearsonCorrelation(histories[i].prices, histories[j].prices);
+      if (Math.abs(corr) >= minCorrelation) {
+        correlations.push({
+          token_a: tokens[i],
+          token_b: tokens[j],
+          correlation: corr,
+          strength: Math.abs(corr) > 0.8 ? "STRONG" : Math.abs(corr) > 0.6 ? "MODERATE" : "WEAK",
+          direction: corr > 0 ? "POSITIVE" : "NEGATIVE",
+          data_points: Math.min(histories[i].prices.length, histories[j].prices.length)
+        });
+      }
+    }
+  }
+  correlations.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation));
+  return {
+    tokens_analyzed: tokens.length,
+    pairs_checked: tokens.length * (tokens.length - 1) / 2,
+    significant_correlations: correlations.length,
+    correlations,
+    arbitrage_candidates: correlations.filter((c) => Math.abs(c.correlation) > 0.8).map((c) => ({
+      ...c,
+      note: c.direction === "NEGATIVE" ? "Negatively correlated \u2014 if one goes up, the other goes down. Check if pricing is consistent." : "Strongly correlated \u2014 prices should move together. Divergence = opportunity."
+    }))
+  };
+}
+async function scanArbitrage(params) {
+  const opportunities = [];
+  let markets = [];
+  if (params.market_slugs?.length) {
+    const fetches = await Promise.all(params.market_slugs.map(
+      (s) => cachedFetchJSON(`${GAMMA_API}/markets?slug=${s}`).catch(() => [])
+    ));
+    markets = fetches.flat();
+  } else {
+    markets = await cachedFetchJSON(`${GAMMA_API}/markets?active=true&closed=false&limit=50&order=volume24hr&ascending=false`).catch(() => []);
+  }
+  const scanType = params.scan_type || "all";
+  const minProfit = params.min_profit_pct || 0.5;
+  if (scanType === "yes_no" || scanType === "all") {
+    for (const m of markets) {
+      try {
+        const prices = m.outcomePrices ? JSON.parse(m.outcomePrices) : [];
+        if (prices.length === 2) {
+          const yes = parseFloat(prices[0]);
+          const no = parseFloat(prices[1]);
+          const sum = yes + no;
+          const deviation = Math.abs(sum - 1) * 100;
+          if (deviation >= minProfit) {
+            opportunities.push({
+              type: "yes_no_mispricing",
+              market: m.question,
+              slug: m.slug,
+              yes_price: yes,
+              no_price: no,
+              sum: +sum.toFixed(4),
+              profit_pct: +deviation.toFixed(2),
+              action: sum > 1 ? "SELL both YES and NO (overpriced)" : "BUY both YES and NO (underpriced)"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (scanType === "multi_outcome" || scanType === "all") {
+    for (const m of markets) {
+      try {
+        const prices = m.outcomePrices ? JSON.parse(m.outcomePrices) : [];
+        if (prices.length > 2) {
+          const sum = prices.reduce((s, p) => s + parseFloat(p), 0);
+          const deviation = Math.abs(sum - 1) * 100;
+          if (deviation >= minProfit) {
+            opportunities.push({
+              type: "multi_outcome_mispricing",
+              market: m.question,
+              slug: m.slug,
+              outcomes: prices.length,
+              prices: prices.map(Number),
+              sum: +sum.toFixed(4),
+              profit_pct: +deviation.toFixed(2),
+              action: sum > 1 ? "SELL all outcomes (combined price exceeds 100%)" : "BUY all outcomes (combined price below 100%)"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (scanType === "cross_market" || scanType === "all") {
+    const groups = /* @__PURE__ */ new Map();
+    for (const m of markets) {
+      const key = (m.question || "").toLowerCase().replace(/[^a-z0-9]/g, " ").replace(/\s+/g, " ").trim().slice(0, 50);
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(m);
+    }
+    for (const [key, group] of Array.from(groups.entries())) {
+      if (group.length < 2) continue;
+      const prices = group.map((m2) => {
+        const p = m2.outcomePrices ? JSON.parse(m2.outcomePrices) : [];
+        return { slug: m2.slug, question: m2.question, yes: parseFloat(p[0] || "0") };
+      });
+      const maxPrice = Math.max(...prices.map((p) => p.yes));
+      const minPrice = Math.min(...prices.map((p) => p.yes));
+      const diff = (maxPrice - minPrice) * 100;
+      if (diff >= minProfit) {
+        opportunities.push({
+          type: "cross_market_divergence",
+          topic: key,
+          markets: prices,
+          price_spread: +diff.toFixed(2),
+          action: `Buy cheapest (${minPrice.toFixed(3)}), sell most expensive (${maxPrice.toFixed(3)})`
+        });
+      }
+    }
+  }
+  opportunities.sort((a, b) => (b.profit_pct || b.price_spread || 0) - (a.profit_pct || a.price_spread || 0));
+  return {
+    markets_scanned: markets.length,
+    opportunities_found: opportunities.length,
+    opportunities: opportunities.slice(0, 20),
+    total_potential_profit: opportunities.reduce((s, o) => s + (o.profit_pct || o.price_spread || 0), 0).toFixed(2) + "%"
+  };
+}
+async function detectRegime(tokenId, lookback = 72) {
+  const prices = await fetchPriceHistory(tokenId);
+  if (prices.length < 20) throw new Error("Insufficient price history (need 20+ data points)");
+  const lb = Math.min(lookback, prices.length);
+  const recentPrices = prices.slice(-lb);
+  const hurst = calculateHurst(recentPrices);
+  const vol = calculateVolatility(recentPrices);
+  const n = recentPrices.length;
+  const xMean = (n - 1) / 2;
+  const yMean = recentPrices.reduce((s, p) => s + p, 0) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (i - xMean) * (recentPrices[i] - yMean);
+    den += (i - xMean) ** 2;
+  }
+  const slope = den > 0 ? num / den : 0;
+  let regime;
+  let confidence;
+  if (hurst > 0.6) {
+    regime = "TRENDING";
+    confidence = Math.min(1, (hurst - 0.5) * 5);
+  } else if (hurst < 0.4) {
+    regime = "MEAN_REVERTING";
+    confidence = Math.min(1, (0.5 - hurst) * 5);
+  } else {
+    regime = "RANDOM_WALK";
+    confidence = 1 - Math.abs(hurst - 0.5) * 5;
+  }
+  const strategies = {
+    TRENDING: [
+      "Follow the trend \u2014 buy on dips in an uptrend, sell rallies in a downtrend",
+      "Use momentum indicators (moving averages, breakout levels)",
+      "Set trailing stops to ride the trend",
+      "DO NOT mean-revert \u2014 the trend is your friend"
+    ],
+    MEAN_REVERTING: [
+      "Buy when price dips below recent mean, sell when it rises above",
+      "Use Bollinger Bands or standard deviation channels",
+      "Set target at mean price \u2014 profits come from reversion",
+      "DO NOT chase breakouts \u2014 they will likely reverse"
+    ],
+    RANDOM_WALK: [
+      "No persistent pattern \u2014 fundamentals-only trading",
+      "Only trade if you have informational edge (news, insider knowledge)",
+      "Keep positions small \u2014 no statistical edge from technicals",
+      "Focus on event catalysts, not price patterns"
+    ]
+  };
+  return {
+    token_id: tokenId,
+    regime,
+    confidence: +confidence.toFixed(3),
+    hurst_exponent: hurst,
+    volatility_annualized: vol,
+    trend_direction: slope > 0 ? "UP" : slope < 0 ? "DOWN" : "FLAT",
+    slope: +slope.toFixed(6),
+    data_points: recentPrices.length,
+    current_price: recentPrices[recentPrices.length - 1],
+    price_range: { min: +Math.min(...recentPrices).toFixed(4), max: +Math.max(...recentPrices).toFixed(4) },
+    strategies: strategies[regime] || []
+  };
+}
+async function calculateSmartMoneyIndex(tokenId, marketQuestion) {
+  const signals = {};
+  try {
+    const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tokenId}`);
+    const bids = (book?.bids || []).reduce((s, b) => s + parseFloat(b.size) * parseFloat(b.price), 0);
+    const asks = (book?.asks || []).reduce((s, a) => s + parseFloat(a.size) * parseFloat(a.price), 0);
+    const total = bids + asks;
+    signals.orderbook_imbalance = total > 0 ? +((bids / total - 0.5) * 2).toFixed(3) : 0;
+  } catch {
+    signals.orderbook_imbalance = 0;
+  }
+  try {
+    const trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=100`);
+    let buyVol = 0, sellVol = 0;
+    for (const t of trades || []) {
+      const val = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+      if (t.side === "BUY") buyVol += val;
+      else sellVol += val;
+    }
+    const total = buyVol + sellVol;
+    signals.trade_flow = total > 0 ? +((buyVol / total - 0.5) * 2).toFixed(3) : 0;
+  } catch {
+    signals.trade_flow = 0;
+  }
+  try {
+    const prices = await fetchPriceHistory(tokenId);
+    if (prices.length >= 10) {
+      const recent = prices.slice(-5).reduce((s, p) => s + p, 0) / 5;
+      const older = prices.slice(-10, -5).reduce((s, p) => s + p, 0) / 5;
+      signals.momentum = older > 0 ? +((recent - older) / older).toFixed(4) : 0;
+    } else {
+      signals.momentum = 0;
+    }
+  } catch {
+    signals.momentum = 0;
+  }
+  signals.news_sentiment = 0;
+  if (marketQuestion) {
+    try {
+      const xml = await (await fetch(`https://news.google.com/rss/search?q=${encodeURIComponent(marketQuestion)}&hl=en-US&gl=US&ceid=US:en`, { signal: AbortSignal.timeout(8e3) })).text();
+      const titles = (xml.match(/<title>([\s\S]*?)<\/title>/g) || []).map((t) => t.replace(/<\/?title>/g, "").replace(/<!\[CDATA\[|\]\]>/g, ""));
+      const positive = ["yes", "win", "likely", "confirmed", "ahead", "surge", "up"];
+      const negative = ["no", "lose", "unlikely", "denied", "behind", "drop", "down"];
+      let sentScore = 0;
+      for (const t of titles) {
+        const lower = t.toLowerCase();
+        for (const p of positive) if (lower.includes(p)) sentScore += 0.1;
+        for (const nn of negative) if (lower.includes(nn)) sentScore -= 0.1;
+      }
+      signals.news_sentiment = +Math.max(-1, Math.min(1, sentScore)).toFixed(3);
+    } catch {
+    }
+  }
+  const weights = { orderbook_imbalance: 0.3, trade_flow: 0.3, momentum: 0.2, news_sentiment: 0.2 };
+  const composite = +(signals.orderbook_imbalance * weights.orderbook_imbalance + signals.trade_flow * weights.trade_flow + signals.momentum * weights.momentum + signals.news_sentiment * weights.news_sentiment).toFixed(4);
+  const action = composite > 0.3 ? "STRONG_BUY" : composite > 0.1 ? "BUY" : composite < -0.3 ? "STRONG_SELL" : composite < -0.1 ? "SELL" : "HOLD";
+  return {
+    token_id: tokenId,
+    smart_money_index: composite,
+    action,
+    signals,
+    weights,
+    interpretation: {
+      "-1 to -0.3": "Smart money selling aggressively",
+      "-0.3 to -0.1": "Slight sell pressure from informed traders",
+      "-0.1 to 0.1": "No clear smart money direction",
+      "0.1 to 0.3": "Slight buy pressure from informed traders",
+      "0.3 to 1": "Smart money buying aggressively"
+    }
+  };
+}
+async function analyzeMicrostructure(tokenId, orderSizes) {
+  const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tokenId}`);
+  const bids = (book?.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) }));
+  const asks = (book?.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }));
+  const bestBid = bids.length ? Math.max(...bids.map((b) => b.price)) : 0;
+  const bestAsk = asks.length ? Math.min(...asks.map((a) => a.price)) : 1;
+  const midPrice = (bestBid + bestAsk) / 2;
+  const spread = bestAsk - bestBid;
+  const sizes = orderSizes || [100, 500, 1e3, 5e3];
+  const buySimulations = [];
+  const sellSimulations = [];
+  for (const size of sizes) {
+    let remaining = size;
+    let totalCost = 0;
+    let levelsUsed = 0;
+    const sortedAsks = [...asks].sort((a, b) => a.price - b.price);
+    for (const ask of sortedAsks) {
+      if (remaining <= 0) break;
+      const fillSize = Math.min(remaining / ask.price, ask.size);
+      totalCost += fillSize * ask.price;
+      remaining -= fillSize * ask.price;
+      levelsUsed++;
+    }
+    const filled = size - Math.max(0, remaining);
+    const avgPrice = filled > 0 ? totalCost / (totalCost / midPrice) : midPrice;
+    const slippage = midPrice > 0 ? (avgPrice - midPrice) / midPrice * 100 : 0;
+    buySimulations.push({
+      order_size_usdc: size,
+      estimated_fill_pct: +(filled / size * 100).toFixed(1),
+      avg_fill_price: +avgPrice.toFixed(4),
+      slippage_pct: +slippage.toFixed(3),
+      levels_consumed: levelsUsed,
+      recommendation: slippage > 2 ? "USE LIMIT ORDER \u2014 high slippage" : slippage > 0.5 ? "Consider limit order" : "Market order acceptable"
+    });
+    remaining = size;
+    let totalProceeds = 0;
+    levelsUsed = 0;
+    const sortedBids = [...bids].sort((a, b) => b.price - a.price);
+    for (const bid of sortedBids) {
+      if (remaining <= 0) break;
+      const fillSize = Math.min(remaining / bid.price, bid.size);
+      totalProceeds += fillSize * bid.price;
+      remaining -= fillSize * bid.price;
+      levelsUsed++;
+    }
+    const filledSell = size - Math.max(0, remaining);
+    const avgSellPrice = filledSell > 0 ? totalProceeds / (totalProceeds / midPrice) : midPrice;
+    const sellSlippage = midPrice > 0 ? (midPrice - avgSellPrice) / midPrice * 100 : 0;
+    sellSimulations.push({
+      order_size_usdc: size,
+      estimated_fill_pct: +(filledSell / size * 100).toFixed(1),
+      avg_fill_price: +avgSellPrice.toFixed(4),
+      slippage_pct: +sellSlippage.toFixed(3),
+      levels_consumed: levelsUsed
+    });
+  }
+  let recentTrades = [];
+  try {
+    const trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=50`);
+    recentTrades = (trades || []).map((t) => ({ size: parseFloat(t.size || "0"), price: parseFloat(t.price || "0"), side: t.side }));
+  } catch {
+  }
+  const avgTradeSize = recentTrades.length ? +(recentTrades.reduce((s, t) => s + t.size * t.price, 0) / recentTrades.length).toFixed(2) : 0;
+  return {
+    token_id: tokenId,
+    mid_price: +midPrice.toFixed(4),
+    spread: +spread.toFixed(4),
+    spread_bps: +(spread / midPrice * 1e4).toFixed(1),
+    bid_levels: bids.length,
+    ask_levels: asks.length,
+    total_bid_liquidity: +bids.reduce((s, b) => s + b.size * b.price, 0).toFixed(2),
+    total_ask_liquidity: +asks.reduce((s, a) => s + a.size * a.price, 0).toFixed(2),
+    avg_recent_trade_size: avgTradeSize,
+    buy_simulations: buySimulations,
+    sell_simulations: sellSimulations,
+    optimal_order_type: spread > 0.02 ? "LIMIT" : "MARKET",
+    market_quality: spread < 0.01 ? "EXCELLENT" : spread < 0.03 ? "GOOD" : spread < 0.05 ? "FAIR" : "POOR"
+  };
+}
+
+// src/polymarket-engines/onchain.ts
+async function analyzeOrderbookDepth(tokenId) {
+  let book = null;
+  try {
+    book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tokenId}`, 15e3);
+  } catch {
+    try {
+      const gammaData = await cachedFetchJSON(`${GAMMA_API}/markets?clob_token_ids=${tokenId}&limit=1`);
+      if (gammaData?.[0]?.outcomePrices) {
+        const prices = JSON.parse(gammaData[0].outcomePrices);
+        const yesPrice = parseFloat(prices[0]) || 0.5;
+        return {
+          bestBid: +(yesPrice - 0.01).toFixed(4),
+          bestAsk: +(yesPrice + 0.01).toFixed(4),
+          spread: 0.02,
+          spreadPct: +(0.02 / yesPrice * 100).toFixed(2),
+          midpoint: yesPrice,
+          bidDepth: 0,
+          askDepth: 0,
+          imbalance: 0,
+          topBidSize: 0,
+          topAskSize: 0,
+          levels: 0,
+          totalBidLiquidity: 0,
+          totalAskLiquidity: 0,
+          bidWalls: [],
+          askWalls: [],
+          bidDepthByLevel: {},
+          askDepthByLevel: {},
+          spoofIndicators: [],
+          recommendation: "CLOB rate limited \u2014 orderbook data estimated from Gamma. Re-check with poly_orderbook_depth before trading."
+        };
+      }
+    } catch {
+    }
+    throw new Error("CLOB rate limited and no Gamma fallback available");
+  }
+  const bids = (book?.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) }));
+  const asks = (book?.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }));
+  const totalBidLiquidity = bids.reduce((s, b) => s + b.size * b.price, 0);
+  const totalAskLiquidity = asks.reduce((s, a) => s + a.size * a.price, 0);
+  const bestBid = bids.length ? Math.max(...bids.map((b) => b.price)) : 0;
+  const bestAsk = asks.length ? Math.min(...asks.map((a) => a.price)) : 1;
+  const spread = bestAsk - bestBid;
+  const spreadPct = bestBid > 0 ? spread / bestBid * 100 : 0;
+  const midPrice = (bestBid + bestAsk) / 2;
+  const depthLevels = [0.01, 0.02, 0.05, 0.1];
+  const bidDepthByLevel = {};
+  const askDepthByLevel = {};
+  for (const level of depthLevels) {
+    bidDepthByLevel[`${level * 100}%`] = bids.filter((b) => b.price >= bestBid * (1 - level)).reduce((s, b) => s + b.size, 0);
+    askDepthByLevel[`${level * 100}%`] = asks.filter((a) => a.price <= bestAsk * (1 + level)).reduce((s, a) => s + a.size, 0);
+  }
+  const avgBidSize = bids.length ? bids.reduce((s, b) => s + b.size, 0) / bids.length : 0;
+  const avgAskSize = asks.length ? asks.reduce((s, a) => s + a.size, 0) / asks.length : 0;
+  const bidWalls = bids.filter((b) => b.size > avgBidSize * 3).map((b) => ({ price: b.price, size: b.size, multiple: +(b.size / avgBidSize).toFixed(1) }));
+  const askWalls = asks.filter((a) => a.size > avgAskSize * 3).map((a) => ({ price: a.price, size: a.size, multiple: +(a.size / avgAskSize).toFixed(1) }));
+  const totalDepth = totalBidLiquidity + totalAskLiquidity;
+  const imbalance = totalDepth > 0 ? +((totalBidLiquidity - totalAskLiquidity) / totalDepth).toFixed(3) : 0;
+  const spoofIndicators = [];
+  if (bidWalls.length > 2) spoofIndicators.push("Multiple bid walls detected \u2014 possible layering");
+  if (askWalls.length > 2) spoofIndicators.push("Multiple ask walls detected \u2014 possible layering");
+  if (spreadPct > 5) spoofIndicators.push("Wide spread may indicate thin/manipulated market");
+  const recommendation = spreadPct > 3 ? "Wide spread \u2014 use limit orders only, do NOT market buy/sell" : imbalance > 0.65 ? "Strong bid pressure \u2014 consider buying before price moves up" : imbalance < 0.35 ? "Strong sell pressure \u2014 wait for lower prices or go short" : "Balanced book \u2014 safe to trade at market";
+  return {
+    bestBid,
+    bestAsk,
+    spread: +spread.toFixed(4),
+    spreadPct: +spreadPct.toFixed(2),
+    midpoint: midPrice,
+    bidDepth: +totalBidLiquidity.toFixed(2),
+    askDepth: +totalAskLiquidity.toFixed(2),
+    imbalance,
+    topBidSize: bids[0]?.size || 0,
+    topAskSize: asks[0]?.size || 0,
+    levels: Math.max(bids.length, asks.length),
+    totalBidLiquidity: +totalBidLiquidity.toFixed(2),
+    totalAskLiquidity: +totalAskLiquidity.toFixed(2),
+    bidWalls,
+    askWalls,
+    bidDepthByLevel,
+    askDepthByLevel,
+    spoofIndicators,
+    recommendation
+  };
+}
+async function scanWhaleTrades(tokenId, minSize = 1e3) {
+  let trades = null;
+  try {
+    trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=100`, 15e3);
+  } catch {
+    return {
+      token_id: tokenId,
+      total_trades: 0,
+      whale_trades: 0,
+      min_size_filter: minSize,
+      trades: [],
+      summary: { total_whale_volume: 0, avg_whale_size: 0, unique_wallets: 0 }
+    };
+  }
+  const largeTrades = (trades || []).map((t) => ({
+    id: t.id,
+    maker: t.maker_address,
+    taker: t.taker_address,
+    side: t.side,
+    size: parseFloat(t.size || "0"),
+    price: parseFloat(t.price || "0"),
+    timestamp: t.match_time || t.created_at,
+    value: parseFloat(t.size || "0") * parseFloat(t.price || "0")
+  })).filter((t) => t.value >= minSize).sort((a, b) => b.value - a.value);
+  const wallets = /* @__PURE__ */ new Set();
+  for (const t of largeTrades) {
+    if (t.maker) wallets.add(t.maker.toLowerCase());
+    if (t.taker) wallets.add(t.taker.toLowerCase());
+  }
+  return {
+    token_id: tokenId,
+    total_trades: (trades || []).length,
+    whale_trades: largeTrades.length,
+    min_size_filter: minSize,
+    trades: largeTrades.slice(0, 20),
+    summary: {
+      total_whale_volume: +largeTrades.reduce((s, t) => s + t.value, 0).toFixed(2),
+      avg_whale_size: largeTrades.length ? +(largeTrades.reduce((s, t) => s + t.value, 0) / largeTrades.length).toFixed(2) : 0,
+      unique_wallets: wallets.size
+    }
+  };
+}
+async function analyzeFlow(tokenId, windows) {
+  let trades = null;
+  try {
+    trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=500`);
+  } catch {
+    return { token_id: tokenId, flows: {} };
+  }
+  if (!trades?.length) return { token_id: tokenId, flows: {} };
+  const now = Date.now();
+  const windowMs = { "5m": 5 * 6e4, "15m": 15 * 6e4, "1h": 60 * 6e4, "4h": 4 * 60 * 6e4, "24h": 24 * 60 * 6e4 };
+  const requestedWindows = windows || ["1h", "4h", "24h"];
+  const flows = {};
+  for (const window of requestedWindows) {
+    const ms = windowMs[window] || 60 * 6e4;
+    const cutoff = now - ms;
+    const windowTrades = trades.filter((t) => {
+      const ts = new Date(t.match_time || t.created_at).getTime();
+      return ts >= cutoff;
+    });
+    let buyVolume = 0, sellVolume = 0, buyCount = 0, sellCount = 0;
+    for (const t of windowTrades) {
+      const value = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+      if (t.side === "BUY") {
+        buyVolume += value;
+        buyCount++;
+      } else {
+        sellVolume += value;
+        sellCount++;
+      }
+    }
+    const netFlow = buyVolume - sellVolume;
+    flows[window] = {
+      buy_volume: +buyVolume.toFixed(2),
+      sell_volume: +sellVolume.toFixed(2),
+      net_flow: +netFlow.toFixed(2),
+      buy_count: buyCount,
+      sell_count: sellCount,
+      total_trades: windowTrades.length,
+      signal: netFlow > 0 ? "bullish" : netFlow < 0 ? "bearish" : "neutral"
+    };
+  }
+  return { token_id: tokenId, flows };
+}
+async function profileWallet(wallet, tokenId) {
+  const addr = wallet.toLowerCase();
+  const [makerTrades, takerTrades] = await Promise.all([
+    cachedFetchJSON(`${CLOB_API}/trades?maker_address=${addr}&limit=200`).catch(() => []),
+    cachedFetchJSON(`${CLOB_API}/trades?taker_address=${addr}&limit=200`).catch(() => [])
+  ]);
+  const allTrades = [...makerTrades || [], ...takerTrades || []];
+  const filtered = tokenId ? allTrades.filter((t) => t.asset_id === tokenId || t.token_id === tokenId) : allTrades;
+  let totalVolume = 0, buyVolume = 0, sellVolume = 0;
+  const markets = /* @__PURE__ */ new Set();
+  const tokens = /* @__PURE__ */ new Set();
+  for (const t of filtered) {
+    const value = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+    totalVolume += value;
+    if (t.side === "BUY") buyVolume += value;
+    else sellVolume += value;
+    if (t.market) markets.add(t.market);
+    if (t.asset_id || t.token_id) tokens.add(t.asset_id || t.token_id);
+  }
+  return {
+    wallet: addr,
+    total_trades: filtered.length,
+    total_volume: +totalVolume.toFixed(2),
+    buy_volume: +buyVolume.toFixed(2),
+    sell_volume: +sellVolume.toFixed(2),
+    unique_markets: markets.size,
+    unique_tokens: tokens.size,
+    avg_trade_size: filtered.length ? +(totalVolume / filtered.length).toFixed(2) : 0,
+    buy_sell_ratio: sellVolume > 0 ? +(buyVolume / sellVolume).toFixed(2) : buyVolume > 0 ? Infinity : 0,
+    first_trade: filtered.length ? filtered[filtered.length - 1]?.match_time : null,
+    last_trade: filtered.length ? filtered[0]?.match_time : null,
+    recent_trades: filtered.slice(0, 10).map((t) => ({
+      side: t.side,
+      size: parseFloat(t.size || "0"),
+      price: parseFloat(t.price || "0"),
+      value: +(parseFloat(t.size || "0") * parseFloat(t.price || "0")).toFixed(2),
+      time: t.match_time || t.created_at
+    }))
+  };
+}
+async function mapLiquidity(tokenIds) {
+  if (!tokenIds.length) throw new Error("Provide token_ids");
+  const books = await Promise.all(tokenIds.map(async (tid) => {
+    try {
+      const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tid}`, 8e3);
+      const bids = (book?.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) }));
+      const asks = (book?.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }));
+      const totalBid = bids.reduce((s, b) => s + b.size * b.price, 0);
+      const totalAsk = asks.reduce((s, a) => s + a.size * a.price, 0);
+      const bestBid = bids.length ? Math.max(...bids.map((b) => b.price)) : 0;
+      const bestAsk = asks.length ? Math.min(...asks.map((a) => a.price)) : 1;
+      const spread = bestAsk - bestBid;
+      const midPrice = (bestBid + bestAsk) / 2;
+      const spreadPct = midPrice > 0 ? +(spread / midPrice * 100).toFixed(2) : 999;
+      const totalDepth = totalBid + totalAsk;
+      const imbalance = totalDepth > 0 ? +((totalBid - totalAsk) / totalDepth).toFixed(3) : 0;
+      return { token_id: tid, bestBid, bestAsk, midPrice: +midPrice.toFixed(4), spreadPct, totalBidLiquidity: +totalBid.toFixed(2), totalAskLiquidity: +totalAsk.toFixed(2), imbalance, bidLevels: bids.length, askLevels: asks.length, signal: imbalance > 0.3 ? "bullish" : imbalance < -0.3 ? "bearish" : "neutral" };
+    } catch {
+      return { token_id: tid, error: "Failed to fetch" };
+    }
+  }));
+  const ranked = books.filter((b) => !b.error).sort((a, b) => (a.spreadPct || 999) - (b.spreadPct || 999));
+  return {
+    tokens_analyzed: tokenIds.length,
+    liquidity_map: ranked,
+    best_to_trade: ranked[0]?.token_id || null,
+    worst_to_trade: ranked[ranked.length - 1]?.token_id || null,
+    total_liquidity: +ranked.reduce((s, b) => s + (b.totalBidLiquidity || 0) + (b.totalAskLiquidity || 0), 0).toFixed(2),
+    warnings: ranked.filter((b) => b.spreadPct > 5).map((b) => `${b.token_id}: spread ${b.spreadPct}% \u2014 AVOID`)
+  };
+}
+async function decodeTransaction(txHash) {
+  const scanUrl = `https://api.polygonscan.com/api?module=proxy&action=eth_getTransactionByHash&txhash=${txHash}`;
+  const txData = await cachedFetchJSON(scanUrl).catch(() => null);
+  if (!txData?.result) throw new Error("Transaction not found");
+  const result = txData.result;
+  const to = (result.to || "").toLowerCase();
+  const isCtf = to === CTF_ADDRESS.toLowerCase();
+  const methodSig = (result.input || "").slice(0, 10);
+  const methods = {
+    "0x": "ETH Transfer",
+    "0xa9059cbb": "ERC20 Transfer",
+    "0x23b872dd": "ERC20 TransferFrom",
+    "0x2eb2c2d6": "safeBatchTransferFrom (CTF position transfer)",
+    "0xf242432a": "safeTransferFrom (CTF single transfer)",
+    "0xfb16a595": "splitPosition (mint conditional tokens)",
+    "0x7e7e4b47": "mergePositions (redeem conditional tokens)",
+    "0x3b2bcbf1": "redeemPositions (claim winnings)"
+  };
+  return {
+    tx_hash: txHash,
+    from: result.from,
+    to: result.to,
+    value: parseInt(result.value || "0", 16) / 1e18,
+    is_polymarket_ctf: isCtf,
+    method: methods[methodSig] || `Unknown (${methodSig})`,
+    gas_price_gwei: parseInt(result.gasPrice || "0", 16) / 1e9,
+    block: parseInt(result.blockNumber || "0", 16)
+  };
+}
+async function getWalletTransactions(wallet, limit = 20) {
+  const url = `https://api.polygonscan.com/api?module=account&action=txlist&address=${wallet}&startblock=0&endblock=99999999&page=1&offset=${limit}&sort=desc`;
+  const data = await cachedFetchJSON(url);
+  if (!data?.result) return { wallet, total_transactions: 0, polymarket_related: 0, transactions: [] };
+  const txs = (data.result || []).map((tx) => ({
+    hash: tx.hash,
+    to: tx.to,
+    from: tx.from,
+    value_matic: +(parseInt(tx.value || "0") / 1e18).toFixed(4),
+    is_ctf: (tx.to || "").toLowerCase() === CTF_ADDRESS.toLowerCase(),
+    is_usdc: (tx.to || "").toLowerCase() === USDC_ADDRESS.toLowerCase(),
+    method: tx.functionName || tx.methodId,
+    timestamp: new Date(parseInt(tx.timeStamp) * 1e3).toISOString(),
+    status: tx.isError === "0" ? "success" : "failed"
+  }));
+  const polyTxs = txs.filter((t) => t.is_ctf || t.is_usdc);
+  return {
+    wallet,
+    total_transactions: txs.length,
+    polymarket_related: polyTxs.length,
+    transactions: polyTxs.length > 0 ? polyTxs : txs.slice(0, 10)
+  };
+}
+
+// src/polymarket-engines/social.ts
+async function analyzeTwitterSentiment(query, includePolymarket = true) {
+  const searches = [query];
+  if (includePolymarket) searches.push(`${query} polymarket`);
+  const results = [];
+  for (const q of searches) {
+    try {
+      const rssUrl = `https://news.google.com/rss/search?q=${encodeURIComponent(q)}&hl=en-US&gl=US&ceid=US:en`;
+      const xml = await cachedFetchText(rssUrl);
+      const items = [];
+      const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+      let match;
+      while ((match = itemRegex.exec(xml)) !== null) {
+        const get = (tag) => {
+          const m2 = match[1].match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+          return m2 ? m2[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : "";
+        };
+        const title = get("title");
+        if (title) {
+          items.push({ title, link: get("link"), date: get("pubDate"), source: get("source") || "Google News", sentiment: scoreSentiment(title) });
+        }
+      }
+      results.push({ query: q, items: items.slice(0, 15), avg_sentiment: items.length ? +(items.reduce((s, i) => s + i.sentiment, 0) / items.length).toFixed(3) : 0, volume: items.length });
+    } catch (e) {
+      results.push({ query: q, error: e.message, items: [], avg_sentiment: 0, volume: 0 });
+    }
+  }
+  const allItems = results.flatMap((r) => r.items || []);
+  const avgSentiment = allItems.length ? +(allItems.reduce((s, i) => s + i.sentiment, 0) / allItems.length).toFixed(3) : 0;
+  return {
+    query,
+    overall_sentiment: avgSentiment,
+    sentiment_label: avgSentiment > 0.2 ? "BULLISH" : avgSentiment < -0.2 ? "BEARISH" : "NEUTRAL",
+    total_mentions: allItems.length,
+    results,
+    topics_detected: extractTopics(allItems.map((i) => i.title).join(" ")),
+    signal: avgSentiment > 0.3 ? "BUY_SIGNAL" : avgSentiment < -0.3 ? "SELL_SIGNAL" : "NO_SIGNAL"
+  };
+}
+async function analyzePolymarketComments(marketSlug) {
+  const marketData = await cachedFetchJSON(`${GAMMA_API}/markets?slug=${marketSlug}`).catch(() => null);
+  const market = marketData?.[0];
+  if (!market) throw new Error("Market not found \u2014 provide valid slug");
+  const conditionId = market.condition_id || market.conditionId;
+  let comments = [];
+  try {
+    const commentsUrl = `${GAMMA_API}/comments?market=${conditionId}&limit=50&sort=recent`;
+    const commentsData = await cachedFetchJSON(commentsUrl);
+    comments = (commentsData || []).map((c) => ({
+      author: c.author || c.user_id || "anon",
+      text: c.text || c.body || c.content || "",
+      likes: c.likes || c.upvotes || 0,
+      timestamp: c.created_at || c.timestamp,
+      sentiment: scoreSentiment(c.text || c.body || c.content || "")
+    }));
+  } catch {
+  }
+  if (comments.length === 0) {
+    return {
+      market: market.question,
+      slug: marketSlug,
+      total_comments: 0,
+      avg_sentiment: 0,
+      sentiment_label: "NO_DATA",
+      top_comments: [],
+      bullish_comments: 0,
+      bearish_comments: 0,
+      browser_url: `https://polymarket.com/event/${marketSlug}`
+    };
+  }
+  const avgSentiment = +(comments.reduce((s, c) => s + c.sentiment, 0) / comments.length).toFixed(3);
+  return {
+    market: market.question,
+    slug: marketSlug,
+    total_comments: comments.length,
+    avg_sentiment: avgSentiment,
+    sentiment_label: avgSentiment > 0.15 ? "BULLISH" : avgSentiment < -0.15 ? "BEARISH" : "MIXED",
+    top_comments: comments.slice(0, 20),
+    bullish_comments: comments.filter((c) => c.sentiment > 0.2).length,
+    bearish_comments: comments.filter((c) => c.sentiment < -0.2).length
+  };
+}
+async function monitorRedditPulse(query, subreddits, timeframe = "day") {
+  const subs = subreddits || ["polymarket", "politics", "sports", "worldnews"];
+  const results = [];
+  for (const sub of subs) {
+    try {
+      const url = `https://www.reddit.com/r/${sub}/search.json?q=${encodeURIComponent(query)}&restrict_sr=1&sort=relevance&t=${timeframe}&limit=25`;
+      const data = await cachedFetchJSON(url, 3e4, 15e3);
+      const posts = (data?.data?.children || []).map((child) => {
+        const p = child.data;
+        return {
+          title: p.title,
+          subreddit: p.subreddit,
+          score: p.score,
+          num_comments: p.num_comments,
+          url: `https://reddit.com${p.permalink}`,
+          created: new Date(p.created_utc * 1e3).toISOString(),
+          selftext_preview: (p.selftext || "").slice(0, 200),
+          sentiment: scoreSentiment(p.title + " " + (p.selftext || "")),
+          upvote_ratio: p.upvote_ratio
+        };
+      });
+      results.push({
+        subreddit: sub,
+        posts,
+        avg_sentiment: posts.length ? +(posts.reduce((s, p) => s + p.sentiment, 0) / posts.length).toFixed(3) : 0,
+        total_engagement: posts.reduce((s, p) => s + p.score + p.num_comments, 0)
+      });
+    } catch (e) {
+      results.push({ subreddit: sub, error: e.message, posts: [] });
+    }
+  }
+  const allPosts = results.flatMap((r) => r.posts || []);
+  const avgSentiment = allPosts.length ? +(allPosts.reduce((s, p) => s + p.sentiment, 0) / allPosts.length).toFixed(3) : 0;
+  return {
+    query,
+    subreddits_searched: subs,
+    total_posts: allPosts.length,
+    overall_sentiment: avgSentiment,
+    sentiment_label: avgSentiment > 0.15 ? "BULLISH" : avgSentiment < -0.15 ? "BEARISH" : "NEUTRAL",
+    results,
+    trending: allPosts.sort((a, b) => b.score - a.score).slice(0, 5).map((p) => ({ title: p.title, score: p.score, subreddit: p.subreddit }))
+  };
+}
+async function monitorTelegram(channels, query, limit = 20) {
+  const results = [];
+  for (const channel of channels) {
+    try {
+      const url = `https://t.me/s/${channel.replace("@", "")}`;
+      const html = await cachedFetchText(url, 15e3);
+      const messageRegex = /<div class="tgme_widget_message_text[^"]*"[^>]*>([\s\S]*?)<\/div>/g;
+      const messages = [];
+      let match;
+      while ((match = messageRegex.exec(html)) !== null) {
+        const text = match[1].replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').trim();
+        if (text.length > 10) {
+          messages.push({ text: text.slice(0, 500), sentiment: scoreSentiment(text) });
+        }
+      }
+      const filtered = query ? messages.filter((m) => m.text.toLowerCase().includes(query.toLowerCase())) : messages;
+      results.push({
+        channel: channel.replace("@", ""),
+        messages: filtered.slice(0, limit),
+        total: filtered.length,
+        avg_sentiment: filtered.length ? +(filtered.reduce((s, m) => s + m.sentiment, 0) / filtered.length).toFixed(3) : 0
+      });
+    } catch (e) {
+      results.push({ channel: channel.replace("@", ""), error: e.message, messages: [], total: 0, avg_sentiment: 0 });
+    }
+  }
+  const allMessages = results.flatMap((r) => r.messages || []);
+  return {
+    channels_monitored: channels.length,
+    total_messages: allMessages.length,
+    overall_sentiment: allMessages.length ? +(allMessages.reduce((s, m) => s + m.sentiment, 0) / allMessages.length).toFixed(3) : 0,
+    results
+  };
+}
+async function measureSocialVelocity(topic, compareTopic) {
+  async function measure(t) {
+    const sources = [];
+    try {
+      const encoded = encodeURIComponent(t);
+      const [recent, older] = await Promise.all([
+        cachedFetchText(`https://news.google.com/rss/search?q=${encoded}+when:1h&hl=en-US&gl=US&ceid=US:en`).catch(() => ""),
+        cachedFetchText(`https://news.google.com/rss/search?q=${encoded}+when:24h&hl=en-US&gl=US&ceid=US:en`).catch(() => "")
+      ]);
+      const recentCount = (recent.match(/<item>/g) || []).length;
+      const olderCount = (older.match(/<item>/g) || []).length;
+      const hourlyRate = olderCount > 0 ? olderCount / 24 : 0;
+      const acceleration = hourlyRate > 0 ? recentCount / hourlyRate : recentCount;
+      sources.push({
+        source: "google_news",
+        last_hour: recentCount,
+        last_24h: olderCount,
+        hourly_rate: +hourlyRate.toFixed(1),
+        acceleration: +acceleration.toFixed(2),
+        status: acceleration > 3 ? "SPIKE" : acceleration > 1.5 ? "RISING" : "NORMAL"
+      });
+    } catch {
+    }
+    try {
+      const url = `https://www.reddit.com/search.json?q=${encodeURIComponent(t)}&sort=new&t=day&limit=100`;
+      const data = await cachedFetchJSON(url, 3e4, 15e3);
+      const posts = data?.data?.children || [];
+      const now = Date.now() / 1e3;
+      const lastHour = posts.filter((p) => now - p.data.created_utc < 3600).length;
+      const last24h = posts.length;
+      const hourlyRate = last24h / 24;
+      const acceleration = hourlyRate > 0 ? lastHour / hourlyRate : lastHour;
+      sources.push({
+        source: "reddit",
+        last_hour: lastHour,
+        last_24h: last24h,
+        hourly_rate: +hourlyRate.toFixed(1),
+        acceleration: +acceleration.toFixed(2),
+        status: acceleration > 3 ? "SPIKE" : acceleration > 1.5 ? "RISING" : "NORMAL"
+      });
+    } catch {
+    }
+    const totalAcceleration = sources.length ? +(sources.reduce((s, src) => s + (src.acceleration || 0), 0) / sources.length).toFixed(2) : 0;
+    return {
+      topic: t,
+      sources,
+      composite_acceleration: +totalAcceleration,
+      alert_level: +totalAcceleration > 5 ? "CRITICAL" : +totalAcceleration > 3 ? "HIGH" : +totalAcceleration > 1.5 ? "ELEVATED" : "NORMAL"
+    };
+  }
+  const primary = await measure(topic);
+  const comparison = compareTopic ? await measure(compareTopic) : void 0;
+  return {
+    ...primary,
+    comparison,
+    recommendation: primary.alert_level === "CRITICAL" ? "URGENT: Massive discussion spike detected \u2014 check news immediately and consider trading before the market reprices" : primary.alert_level === "HIGH" ? "Discussion accelerating rapidly \u2014 monitor closely and prepare to trade" : "Normal discussion levels \u2014 no urgency"
+  };
+}
+
+// src/polymarket-engines/feeds.ts
+var SOURCE_URLS = {
+  whitehouse: "https://www.whitehouse.gov/feed/",
+  scotus: "https://www.supremecourt.gov/rss/cases/opinions.xml",
+  sec: "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&type=8-K&dateb=&owner=include&count=20&search_text=&action=getcompany&output=atom",
+  fed: "https://www.federalreserve.gov/feeds/press_all.xml",
+  espn: "https://www.espn.com/espn/rss/news",
+  noaa: "https://alerts.weather.gov/cap/us.php?x=0",
+  congress: "https://www.congress.gov/rss/most-viewed-bills.xml"
+};
+async function fetchOfficialSource(source, query, customUrl) {
+  const url = source === "custom" ? customUrl : SOURCE_URLS[source];
+  if (!url) throw new Error(`Unknown source: ${source}`);
+  const text = await cachedFetchText(url, 15e3);
+  let items = parseRSSItems(text);
+  if (items.length === 0) {
+    const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
+    let match;
+    while ((match = entryRegex.exec(text)) !== null) {
+      const get = (tag) => {
+        const m2 = match[1].match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+        return m2 ? m2[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : "";
+      };
+      const linkMatch = match[1].match(/<link[^>]*href="([^"]+)"/);
+      items.push({
+        title: get("title"),
+        link: linkMatch?.[1] || "",
+        pubDate: get("updated") || get("published"),
+        description: get("summary").replace(/<[^>]+>/g, "").slice(0, 300)
+      });
+    }
+  }
+  const filtered = query ? items.filter((i) => (i.title + " " + i.description).toLowerCase().includes(query.toLowerCase())) : items;
+  return {
+    source,
+    url,
+    total_items: items.length,
+    filtered: filtered.length,
+    items: filtered.slice(0, 25),
+    latest: filtered[0] || null
+  };
+}
+async function compareOdds(marketQuestion, polymarketPrice) {
+  const searches = [`${marketQuestion} odds betting`, `${marketQuestion} prediction probability`];
+  const references = [];
+  for (const q of searches) {
+    try {
+      const xml = await cachedFetchText(`https://news.google.com/rss/search?q=${encodeURIComponent(q)}&hl=en-US&gl=US&ceid=US:en`);
+      const items = parseRSSItems(xml);
+      for (const item of items.slice(0, 5)) {
+        const oddsMatch = item.title.match(/(\d+)%/);
+        const ratioMatch = item.title.match(/(\d+)[/-](\d+)/);
+        references.push({
+          source: item.source || "News",
+          headline: item.title,
+          link: item.link,
+          extracted_probability: oddsMatch ? parseInt(oddsMatch[1]) / 100 : null,
+          extracted_odds: ratioMatch ? `${ratioMatch[1]}/${ratioMatch[2]}` : null,
+          date: item.pubDate
+        });
+      }
+    } catch {
+    }
+  }
+  const oddsSites = [
+    { name: "Betfair", note: "UK-based exchange \u2014 check betfair.com for odds" },
+    { name: "Pinnacle", note: "Sharp book \u2014 their odds are considered most efficient" },
+    { name: "Metaculus", note: "Forecasting platform \u2014 check metaculus.com" },
+    { name: "Manifold Markets", note: "Play-money market \u2014 check manifold.markets" }
+  ];
+  let divergence = null;
+  if (polymarketPrice) {
+    const externalOdds = references.filter((r) => r.extracted_probability).map((r) => r.extracted_probability);
+    if (externalOdds.length > 0) {
+      const avgExternal = externalOdds.reduce((s, o) => s + o, 0) / externalOdds.length;
+      divergence = {
+        polymarket: polymarketPrice,
+        external_avg: +avgExternal.toFixed(3),
+        difference: +(polymarketPrice - avgExternal).toFixed(3),
+        pct_difference: +((polymarketPrice - avgExternal) / avgExternal * 100).toFixed(1),
+        signal: Math.abs(polymarketPrice - avgExternal) > 0.05 ? polymarketPrice > avgExternal ? "POLYMARKET_OVERPRICED" : "POLYMARKET_UNDERPRICED" : "ALIGNED"
+      };
+    }
+  }
+  return {
+    market_question: marketQuestion,
+    polymarket_price: polymarketPrice || "not provided",
+    external_references: references,
+    odds_comparison_sites: oddsSites,
+    divergence,
+    recommendation: divergence?.signal === "POLYMARKET_UNDERPRICED" ? "Polymarket is cheaper than external odds \u2014 potential BUY opportunity" : divergence?.signal === "POLYMARKET_OVERPRICED" ? "Polymarket is more expensive than external odds \u2014 consider SELL/SHORT" : "Prices roughly aligned across platforms"
+  };
+}
+async function trackResolution(marketSlug, conditionId) {
+  let market = null;
+  if (marketSlug) {
+    const data = await cachedFetchJSON(`${GAMMA_API}/markets?slug=${marketSlug}`);
+    market = data?.[0];
+  } else if (conditionId) {
+    const data = await cachedFetchJSON(`${GAMMA_API}/markets?condition_id=${conditionId}`);
+    market = data?.[0];
+  }
+  if (!market) throw new Error("Market not found");
+  const description = market.description || "";
+  const resolutionSource = market.resolution_source || market.resolutionSource || "";
+  const urlRegex = /https?:\/\/[^\s<>"']+/g;
+  const urls = Array.from(/* @__PURE__ */ new Set([...description.match(urlRegex) || [], ...resolutionSource.match(urlRegex) || []]));
+  const descLower = description.toLowerCase();
+  let resolutionType = "unknown";
+  if (descLower.includes("associated press") || descLower.includes(" ap ")) resolutionType = "AP call";
+  else if (descLower.includes("espn") || descLower.includes("sports")) resolutionType = "sports result";
+  else if (descLower.includes("government") || descLower.includes("official")) resolutionType = "government source";
+  else if (descLower.includes("court") || descLower.includes("ruling")) resolutionType = "court decision";
+  else if (descLower.includes("sec") || descLower.includes("filing")) resolutionType = "regulatory filing";
+  else if (descLower.includes("price") || descLower.includes("close")) resolutionType = "market price";
+  else if (urls.length > 0) resolutionType = "external source";
+  return {
+    market: market.question,
+    slug: market.slug,
+    condition_id: market.condition_id || market.conditionId,
+    end_date: market.end_date_iso || market.endDate,
+    resolution_source: resolutionSource,
+    resolution_type: resolutionType,
+    resolution_description: description.slice(0, 1e3),
+    source_urls: urls,
+    current_price: market.outcomePrices ? JSON.parse(market.outcomePrices) : null,
+    recommendation: `Monitor these sources directly: ${urls.join(", ") || "Check market description for resolution criteria"}`,
+    risk_factors: [
+      market.active === false ? "MARKET INACTIVE" : "",
+      descLower.includes("discretion") ? "Resolution may involve discretionary judgment" : "",
+      descLower.includes("ambiguous") ? "Resolution criteria may be ambiguous" : "",
+      !resolutionSource ? "No explicit resolution source specified" : ""
+    ].filter(Boolean)
+  };
+}
+async function fetchBreakingNews(params) {
+  const rssFeeds = {
+    ap: "https://rsshub.app/apnews/topics/apf-topnews",
+    reuters: "https://news.google.com/rss/search?q=site:reuters.com&hl=en-US&gl=US&ceid=US:en",
+    bbc: "https://feeds.bbci.co.uk/news/rss.xml",
+    cnn: "https://rss.cnn.com/rss/cnn_topstories.rss"
+  };
+  const requestedSources = params?.sources || Object.keys(rssFeeds);
+  const topics = params?.topics || null;
+  const sinceMs = (params?.since_minutes || 60) * 60 * 1e3;
+  const cutoff = new Date(Date.now() - sinceMs);
+  const allItems = [];
+  await Promise.all(requestedSources.map(async (source) => {
+    const url = rssFeeds[source];
+    if (!url) return;
+    try {
+      const xml = await cachedFetchText(url, 15e3);
+      const items = parseRSSItems(xml);
+      for (const item of items) {
+        const pubDate = item.pubDate ? new Date(item.pubDate) : /* @__PURE__ */ new Date();
+        if (pubDate < cutoff) continue;
+        if (topics) {
+          const lower = (item.title + " " + item.description).toLowerCase();
+          if (!topics.some((t) => lower.includes(t.toLowerCase()))) continue;
+        }
+        const title = item.title.toLowerCase();
+        let relevance = 0;
+        const marketKeywords = [
+          "election",
+          "trump",
+          "biden",
+          "fed",
+          "rate",
+          "court",
+          "ruling",
+          "war",
+          "peace",
+          "crypto",
+          "bitcoin",
+          "ai",
+          "congress",
+          "bill",
+          "vote",
+          "poll",
+          "indictment",
+          "verdict",
+          "championship",
+          "spacex",
+          "launch",
+          "earthquake",
+          "hurricane"
+        ];
+        for (const kw of marketKeywords) {
+          if (title.includes(kw)) relevance += 0.2;
+        }
+        relevance = Math.min(1, relevance);
+        allItems.push({ ...item, source, relevance: +relevance.toFixed(2), minutes_ago: Math.round((Date.now() - pubDate.getTime()) / 6e4) });
+      }
+    } catch {
+    }
+  }));
+  allItems.sort((a, b) => (a.minutes_ago || 999) - (b.minutes_ago || 999));
+  const highRelevance = allItems.filter((i) => i.relevance >= 0.4);
+  return {
+    sources_checked: requestedSources,
+    total_items: allItems.length,
+    high_relevance: highRelevance.length,
+    items: allItems.slice(0, 30),
+    market_moving: highRelevance.slice(0, 10),
+    alert: highRelevance.length > 0 ? `${highRelevance.length} potentially market-moving headlines detected \u2014 review immediately` : "No high-relevance breaking news in the last " + (params?.since_minutes || 60) + " minutes"
+  };
+}
+
+// src/polymarket-engines/counterintel.ts
+async function detectManipulation(tokenId) {
+  const trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=500`);
+  if (!trades?.length) return { token_id: tokenId, trades_analyzed: 0, risk_level: "LOW", risk_score: 0, alerts: [], top_wallets: [], recommendation: "No trades to analyze" };
+  const alerts = [];
+  let riskScore = 0;
+  const selfDeals = trades.filter((t) => t.maker_address && t.taker_address && t.maker_address.toLowerCase() === t.taker_address.toLowerCase());
+  if (selfDeals.length > 0) {
+    const pct = selfDeals.length / trades.length * 100;
+    alerts.push({
+      type: "WASH_TRADING",
+      severity: pct > 10 ? "HIGH" : "MEDIUM",
+      detail: `${selfDeals.length} self-deals (${pct.toFixed(1)}% of trades). Same wallet on both sides.`,
+      wallets: Array.from(new Set(selfDeals.map((t) => t.maker_address))).slice(0, 5)
+    });
+    riskScore += pct > 10 ? 3 : 1;
+  }
+  const walletVolume = /* @__PURE__ */ new Map();
+  for (const t of trades) {
+    for (const addr of [t.maker_address, t.taker_address].filter(Boolean)) {
+      const key = addr.toLowerCase();
+      const val = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+      walletVolume.set(key, (walletVolume.get(key) || 0) + val);
+    }
+  }
+  const totalVolume = Array.from(walletVolume.values()).reduce((s, v) => s + v, 0);
+  const topWallets = Array.from(walletVolume.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  const topPct = totalVolume > 0 ? (topWallets[0]?.[1] || 0) / totalVolume * 100 : 0;
+  if (topPct > 50) {
+    alerts.push({ type: "VOLUME_CONCENTRATION", severity: "HIGH", detail: `Top wallet controls ${topPct.toFixed(1)}% of volume \u2014 market may be easily manipulated.` });
+    riskScore += 3;
+  } else if (topPct > 30) {
+    alerts.push({ type: "VOLUME_CONCENTRATION", severity: "MEDIUM", detail: `Top wallet controls ${topPct.toFixed(1)}% of volume.` });
+    riskScore += 1;
+  }
+  const tradesByTime = trades.map((t) => ({ ...t, ts: new Date(t.match_time || t.created_at).getTime() })).sort((a, b) => a.ts - b.ts);
+  let rapidBursts = 0;
+  for (let i = 1; i < tradesByTime.length; i++) {
+    if (tradesByTime[i].ts - tradesByTime[i - 1].ts < 1e3) rapidBursts++;
+  }
+  const rapidPct = trades.length > 0 ? rapidBursts / trades.length * 100 : 0;
+  if (rapidPct > 20) {
+    alerts.push({ type: "RAPID_FIRE_TRADING", severity: "MEDIUM", detail: `${rapidPct.toFixed(1)}% of trades are <1 second apart \u2014 possible bot activity or spoofing.` });
+    riskScore += 2;
+  }
+  const priceSeries = tradesByTime.map((t) => parseFloat(t.price || "0")).filter((p) => p > 0);
+  let maxSwing = 0;
+  for (let i = 10; i < priceSeries.length; i++) {
+    const window = priceSeries.slice(i - 10, i);
+    const swing = (Math.max(...window) - Math.min(...window)) / Math.min(...window) * 100;
+    if (swing > maxSwing) maxSwing = swing;
+  }
+  if (maxSwing > 20) {
+    alerts.push({ type: "PRICE_MANIPULATION", severity: "HIGH", detail: `${maxSwing.toFixed(1)}% price swing in 10-trade window \u2014 possible pump/dump.` });
+    riskScore += 3;
+  }
+  try {
+    const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tokenId}`);
+    const bidSizes = (book?.bids || []).map((b) => Math.round(parseFloat(b.size)));
+    const sameSizeBids = bidSizes.filter((s, i) => i > 0 && s === bidSizes[i - 1]).length;
+    if (sameSizeBids > 5) {
+      alerts.push({ type: "ORDERBOOK_LAYERING", severity: "MEDIUM", detail: `${sameSizeBids} consecutive same-sized bid orders \u2014 possible layering to create fake support.` });
+      riskScore += 2;
+    }
+  } catch {
+  }
+  const risk = riskScore >= 6 ? "HIGH" : riskScore >= 3 ? "MEDIUM" : "LOW";
+  return {
+    token_id: tokenId,
+    trades_analyzed: trades.length,
+    risk_level: risk,
+    risk_score: riskScore,
+    alerts,
+    top_wallets: topWallets.slice(0, 5).map(([addr, vol]) => ({ address: addr, volume: +vol.toFixed(2), pct: +(vol / totalVolume * 100).toFixed(1) })),
+    recommendation: risk === "HIGH" ? "DANGER: Multiple manipulation indicators detected. Do NOT place large orders. Consider avoiding this market entirely." : risk === "MEDIUM" ? "CAUTION: Some suspicious patterns detected. Use limit orders only, keep positions small." : "No significant manipulation detected. Normal trading activity."
+  };
+}
+async function assessResolutionRisk(marketSlug, conditionId) {
+  let market = null;
+  if (marketSlug?.startsWith("0x")) {
+    conditionId = marketSlug;
+    marketSlug = void 0;
+  }
+  if (marketSlug) {
+    let data = await cachedFetchJSON(`${GAMMA_API}/markets?slug=${marketSlug}`).catch(() => null);
+    market = data?.[0];
+    if (!market) {
+      data = await cachedFetchJSON(`${GAMMA_API}/markets?search=${encodeURIComponent(marketSlug)}&limit=1`).catch(() => null);
+      market = data?.[0];
+    }
+  }
+  if (!market && conditionId) {
+    const data = await cachedFetchJSON(`${GAMMA_API}/markets?condition_id=${conditionId}`).catch(() => null);
+    market = data?.[0];
+  }
+  if (!market) throw new Error("Market not found \u2014 try passing a valid slug or condition_id (0x...)");
+  const question = (market.question || "").toLowerCase();
+  const description = (market.description || "").toLowerCase();
+  const combined = question + " " + description;
+  const risks = [];
+  let riskScore = 0;
+  const ambiguousTerms = ["might", "could", "may", "approximately", "around", "roughly", "about", "substantially", "significantly", "effectively", "practically", "essentially"];
+  const foundAmbiguous = ambiguousTerms.filter((t) => combined.includes(t));
+  if (foundAmbiguous.length > 0) {
+    risks.push({ type: "AMBIGUOUS_LANGUAGE", terms: foundAmbiguous, severity: "MEDIUM", detail: `Resolution criteria contain vague terms: ${foundAmbiguous.join(", ")}` });
+    riskScore += foundAmbiguous.length;
+  }
+  const subjectiveTerms = ["in the opinion", "at discretion", "reasonably", "judgment", "interpret", "determine", "decide", "deem"];
+  const foundSubjective = subjectiveTerms.filter((t) => combined.includes(t));
+  if (foundSubjective.length > 0) {
+    risks.push({ type: "SUBJECTIVE_RESOLUTION", terms: foundSubjective, severity: "HIGH", detail: `Resolution may depend on subjective judgment: ${foundSubjective.join(", ")}` });
+    riskScore += foundSubjective.length * 2;
+  }
+  const hasUrl = /https?:\/\//.test(description);
+  const hasSource = /resolution source|resolv.*based on|determined by|according to/.test(combined);
+  if (!hasUrl && !hasSource) {
+    risks.push({ type: "NO_RESOLUTION_SOURCE", severity: "HIGH", detail: "No explicit resolution source or URL found in market description" });
+    riskScore += 3;
+  }
+  const hasDeadline = market.end_date_iso || market.endDate;
+  if (!hasDeadline) {
+    risks.push({ type: "NO_END_DATE", severity: "MEDIUM", detail: "No clear end date \u2014 market could remain open indefinitely" });
+    riskScore += 2;
+  }
+  const volume = parseFloat(market.volume || "0");
+  const liquidity = parseFloat(market.liquidity || "0");
+  if (volume < 1e4) {
+    risks.push({ type: "LOW_VOLUME", severity: "MEDIUM", detail: `Volume only $${volume.toFixed(0)} \u2014 thin market, hard to exit` });
+    riskScore += 1;
+  }
+  if (liquidity < 5e3) {
+    risks.push({ type: "LOW_LIQUIDITY", severity: "MEDIUM", detail: `Liquidity only $${liquidity.toFixed(0)} \u2014 high slippage risk` });
+    riskScore += 1;
+  }
+  const andCount = (question.match(/\band\b/g) || []).length;
+  const orCount = (question.match(/\bor\b/g) || []).length;
+  if (andCount + orCount >= 3) {
+    risks.push({ type: "COMPLEX_CONDITIONS", severity: "MEDIUM", detail: `Question has ${andCount} AND + ${orCount} OR clauses \u2014 complex resolution criteria` });
+    riskScore += 2;
+  }
+  const risk = riskScore >= 8 ? "HIGH" : riskScore >= 4 ? "MEDIUM" : "LOW";
+  return {
+    market: market.question,
+    slug: market.slug,
+    risk_level: risk,
+    risk_score: riskScore,
+    risks,
+    end_date: hasDeadline || "not specified",
+    volume,
+    liquidity,
+    recommendation: risk === "HIGH" ? "AVOID this market \u2014 high probability of resolution disputes, ambiguity, or void." : risk === "MEDIUM" ? "Proceed with caution. Review resolution criteria carefully. Keep position small." : "Resolution criteria appear clear and well-defined. Proceed normally."
+  };
+}
+async function analyzeCounterparties(tokenId, side) {
+  const trades = await cachedFetchJSON(`${CLOB_API}/trades?token_id=${tokenId}&limit=500`);
+  if (!trades?.length) return { token_id: tokenId, total_traders: 0, breakdown: { whales: { count: 0, volume: 0, pct: 0 }, mid_size: { count: 0, volume: 0 }, retail: { count: 0, volume: 0 } }, top_whales: [], opposite_side_analysis: null, risk_assessment: "No trades to analyze" };
+  const walletStats = /* @__PURE__ */ new Map();
+  for (const t of trades) {
+    const value = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+    for (const [addr] of [[t.maker_address, "maker"], [t.taker_address, "taker"]]) {
+      if (!addr) continue;
+      const key = addr.toLowerCase();
+      if (!walletStats.has(key)) walletStats.set(key, { volume: 0, tradeCount: 0, sides: /* @__PURE__ */ new Set() });
+      const stats = walletStats.get(key);
+      stats.volume += value;
+      stats.tradeCount++;
+      stats.sides.add(t.side);
+    }
+  }
+  const wallets = Array.from(walletStats.entries()).map(([addr, stats]) => ({
+    address: addr,
+    ...stats,
+    sides: Array.from(stats.sides),
+    category: stats.volume > 1e4 ? "WHALE" : stats.volume > 1e3 ? "MID" : "RETAIL"
+  }));
+  const whales = wallets.filter((w) => w.category === "WHALE");
+  const mids = wallets.filter((w) => w.category === "MID");
+  const retail = wallets.filter((w) => w.category === "RETAIL");
+  const whaleVolume = whales.reduce((s, w) => s + w.volume, 0);
+  const totalVolume = wallets.reduce((s, w) => s + w.volume, 0);
+  const whalePct = totalVolume > 0 ? whaleVolume / totalVolume * 100 : 0;
+  let oppositeAnalysis = null;
+  if (side) {
+    const oppositeSide = side === "BUY" ? "SELL" : "BUY";
+    const oppTrades = trades.filter((t) => t.side === oppositeSide);
+    const oppWallets = /* @__PURE__ */ new Map();
+    for (const t of oppTrades) {
+      const addr = (t.maker_address || t.taker_address || "").toLowerCase();
+      const val = parseFloat(t.size || "0") * parseFloat(t.price || "0");
+      oppWallets.set(addr, (oppWallets.get(addr) || 0) + val);
+    }
+    const oppBySize = Array.from(oppWallets.entries()).sort((a, b) => b[1] - a[1]);
+    const topOpp = oppBySize[0];
+    oppositeAnalysis = {
+      your_side: side,
+      opposite_side: oppositeSide,
+      unique_counterparties: oppWallets.size,
+      top_counterparty_volume: topOpp ? +topOpp[1].toFixed(2) : 0,
+      concentration: oppWallets.size > 0 && topOpp ? +(topOpp[1] / Array.from(oppWallets.values()).reduce((s, v) => s + v, 0) * 100).toFixed(1) : 0
+    };
+  }
+  return {
+    token_id: tokenId,
+    total_traders: wallets.length,
+    breakdown: {
+      whales: { count: whales.length, volume: +whaleVolume.toFixed(2), pct: +whalePct.toFixed(1) },
+      mid_size: { count: mids.length, volume: +mids.reduce((s, w) => s + w.volume, 0).toFixed(2) },
+      retail: { count: retail.length, volume: +retail.reduce((s, w) => s + w.volume, 0).toFixed(2) }
+    },
+    top_whales: whales.sort((a, b) => b.volume - a.volume).slice(0, 5).map((w) => ({ address: w.address, volume: +w.volume.toFixed(2), trades: w.tradeCount, sides: w.sides })),
+    opposite_side_analysis: oppositeAnalysis,
+    risk_assessment: whalePct > 70 ? "HIGH RISK: Whales dominate this market. They likely have better information." : whalePct > 40 ? "MODERATE: Mix of whale and retail activity." : "FAVORABLE: Mostly retail counterparties. Your informational edge is likely stronger."
+  };
+}
+
+// src/polymarket-engines/portfolio.ts
+async function analyzePortfolio(positions) {
+  const enriched = await Promise.all(positions.map(async (pos) => {
+    let currentPrice = pos.avg_price;
+    try {
+      const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${pos.token_id}`, 8e3);
+      const bestBid = Math.max(...(book?.bids || []).map((b) => parseFloat(b.price)), 0);
+      const bestAsk = Math.min(...(book?.asks || []).map((a) => parseFloat(a.price)), 1);
+      currentPrice = (bestBid + bestAsk) / 2;
+    } catch {
+    }
+    const value = pos.size * currentPrice;
+    const costBasis = pos.size * pos.avg_price;
+    const pnl = value - costBasis;
+    return {
+      ...pos,
+      current_price: +currentPrice.toFixed(4),
+      value: +value.toFixed(2),
+      cost_basis: +costBasis.toFixed(2),
+      pnl: +pnl.toFixed(2),
+      pnl_pct: costBasis > 0 ? +(pnl / costBasis * 100).toFixed(2) : 0,
+      weight: 0
+      // filled below
+    };
+  }));
+  const totalValue = enriched.reduce((s, p) => s + p.value, 0);
+  const totalCost = enriched.reduce((s, p) => s + p.cost_basis, 0);
+  for (const p of enriched) p.weight = totalValue > 0 ? +(p.value / totalValue * 100).toFixed(1) : 0;
+  const weights = enriched.map((p) => p.value / (totalValue || 1));
+  const hhi = +(weights.reduce((s, w) => s + w * w, 0) * 1e4).toFixed(0);
+  const topPct = Math.max(...weights) * 100;
+  let portfolioVol = 0;
+  try {
+    const vols = await Promise.all(enriched.slice(0, 5).map(async (p) => {
+      const prices = await fetchPriceHistory(p.token_id);
+      return prices.length >= 5 ? calculateVolatility(prices) : 0.5;
+    }));
+    portfolioVol = +Math.sqrt(vols.reduce((s, v, i) => s + (weights[i] || 0) ** 2 * v ** 2, 0)).toFixed(4);
+  } catch {
+    portfolioVol = 0;
+  }
+  return {
+    total_value: +totalValue.toFixed(2),
+    total_cost: +totalCost.toFixed(2),
+    total_pnl: +(totalValue - totalCost).toFixed(2),
+    total_pnl_pct: totalCost > 0 ? +((totalValue - totalCost) / totalCost * 100).toFixed(2) : 0,
+    positions: enriched.sort((a, b) => b.value - a.value),
+    concentration: {
+      hhi,
+      top_position_pct: +topPct.toFixed(1),
+      diversified: hhi < 2500 && topPct < 40
+    },
+    risk_metrics: {
+      portfolio_volatility: portfolioVol,
+      max_single_loss: +Math.max(...enriched.map((p) => p.value)).toFixed(2),
+      correlation_risk: enriched.length > 5 ? "Check correlation matrix" : enriched.length <= 2 ? "HIGH \u2014 too few positions" : "MODERATE"
+    }
+  };
+}
+async function buildCorrelationMatrix(tokenIds) {
+  const tokens = tokenIds.slice(0, 10);
+  const histories = await Promise.all(tokens.map((tid) => fetchPriceHistory(tid)));
+  const n = tokens.length;
+  const matrix = Array.from({ length: n }, () => Array(n).fill(0));
+  const highCorr = [];
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const corr = pearsonCorrelation(histories[i], histories[j]);
+      matrix[i][j] = +corr.toFixed(3);
+      matrix[j][i] = +corr.toFixed(3);
+      if (Math.abs(corr) > 0.5) {
+        highCorr.push({ pair: [tokens[i], tokens[j]], correlation: +corr.toFixed(3) });
+      }
+    }
+  }
+  let sumAbsCorr = 0, count = 0;
+  for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+    sumAbsCorr += Math.abs(matrix[i][j]);
+    count++;
+  }
+  const avgCorr = count > 0 ? sumAbsCorr / count : 0;
+  const divScore = +((1 - avgCorr) * 100).toFixed(1);
+  return { tokens, matrix, high_correlations: highCorr.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation)), diversification_score: divScore };
+}
+function calculatePortfolioKelly(positions, bankroll) {
+  return positions.map((pos) => {
+    const p = pos.estimated_true_prob;
+    const b = 1 / pos.current_price - 1;
+    const q = 1 - p;
+    const kelly = b > 0 ? Math.max(0, (p * b - q) / b) : 0;
+    const halfKelly = kelly / 2;
+    return {
+      token_id: pos.token_id,
+      market: pos.market,
+      estimated_edge: +((p - pos.current_price) * 100).toFixed(2),
+      kelly_fraction: +kelly.toFixed(4),
+      half_kelly: +halfKelly.toFixed(4),
+      recommended_allocation_pct: +(halfKelly * 100).toFixed(2),
+      recommended_size_usd: +(bankroll * halfKelly).toFixed(2)
+    };
+  }).sort((a, b) => b.recommended_size_usd - a.recommended_size_usd);
+}
+function attributePnL(trades) {
+  const totalPnl = trades.reduce((s, t) => s + t.pnl, 0);
+  const winners = trades.filter((t) => t.pnl > 0);
+  const losers = trades.filter((t) => t.pnl < 0);
+  const byMarket = /* @__PURE__ */ new Map();
+  for (const t of trades) byMarket.set(t.market, (byMarket.get(t.market) || 0) + t.pnl);
+  const byPosition = Array.from(byMarket.entries()).map(([market, pnl]) => ({ market, pnl: +pnl.toFixed(2), contribution_pct: totalPnl !== 0 ? +(pnl / Math.abs(totalPnl) * 100).toFixed(1) : 0 })).sort((a, b) => b.pnl - a.pnl);
+  const sorted = [...trades].sort((a, b) => b.pnl - a.pnl);
+  const totalWins = winners.reduce((s, t) => s + t.pnl, 0);
+  const totalLosses = Math.abs(losers.reduce((s, t) => s + t.pnl, 0));
+  return {
+    total_pnl: +totalPnl.toFixed(2),
+    by_position: byPosition,
+    best_trade: sorted[0] ? { market: sorted[0].market, pnl: +sorted[0].pnl.toFixed(2) } : null,
+    worst_trade: sorted[sorted.length - 1] ? { market: sorted[sorted.length - 1].market, pnl: +sorted[sorted.length - 1].pnl.toFixed(2) } : null,
+    win_rate: trades.length > 0 ? +(winners.length / trades.length * 100).toFixed(1) : 0,
+    avg_winner: winners.length > 0 ? +(totalWins / winners.length).toFixed(2) : 0,
+    avg_loser: losers.length > 0 ? +(totalLosses / losers.length).toFixed(2) : 0,
+    profit_factor: totalLosses > 0 ? +(totalWins / totalLosses).toFixed(2) : totalWins > 0 ? Infinity : 0
+  };
+}
+
+// src/polymarket-engines/pipeline.ts
+async function fullAnalysis(params) {
+  const { tokenId, marketSlug, conditionId, marketQuestion, bankroll = 100, side } = params;
+  let market = { question: marketQuestion || "", slug: marketSlug || "", token_id: tokenId, condition_id: conditionId || "" };
+  if (marketSlug) {
+    try {
+      const data = await cachedFetchJSON(`${GAMMA_API}/markets?slug=${marketSlug}`);
+      if (data?.[0]) {
+        market = { question: data[0].question, slug: data[0].slug, token_id: tokenId, condition_id: data[0].condition_id || data[0].conditionId || conditionId || "" };
+      }
+    } catch {
+    }
+  }
+  let currentPrice = params.currentPrice || 0.5;
+  let bestBid = 0, bestAsk = 1;
+  let clobAvailable = true;
+  try {
+    const book = await cachedFetchJSON(`${CLOB_API}/book?token_id=${tokenId}`);
+    bestBid = Math.max(...(book?.bids || []).map((b) => parseFloat(b.price)), 0);
+    bestAsk = Math.min(...(book?.asks || []).map((a) => parseFloat(a.price)), 1);
+    currentPrice = (bestBid + bestAsk) / 2;
+  } catch {
+    clobAvailable = false;
+    try {
+      const gammaData = await cachedFetchJSON(`${GAMMA_API}/markets?clob_token_ids=${tokenId}&limit=1`);
+      if (gammaData?.[0]?.outcomePrices) {
+        const prices = JSON.parse(gammaData[0].outcomePrices);
+        currentPrice = parseFloat(prices[0]) || 0.5;
+      }
+    } catch {
+    }
+  }
+  const estimatedProb = params.estimatedTrueProb || currentPrice;
+  const priceHistory = await fetchPriceHistory(tokenId).catch(() => []);
+  const [
+    regimeResult,
+    smartMoneyResult,
+    microResult,
+    orderbookResult,
+    whaleResult,
+    flowResult,
+    manipulationResult
+  ] = await Promise.all([
+    detectRegime(tokenId).catch(() => null),
+    calculateSmartMoneyIndex(tokenId, market.question).catch(() => null),
+    analyzeMicrostructure(tokenId).catch(() => null),
+    analyzeOrderbookDepth(tokenId).catch(() => null),
+    scanWhaleTrades(tokenId, 500).catch(() => null),
+    analyzeFlow(tokenId).catch(() => null),
+    detectManipulation(tokenId).catch(() => null)
+  ]);
+  let kellyResult = null, technicals = null, volatilityResult = null;
+  let monteCarloResult = null, varResult = null, compositeSignal = null;
+  if (priceHistory.length >= 10) {
+    [kellyResult, technicals, volatilityResult, monteCarloResult, varResult, compositeSignal] = await Promise.all([
+      Promise.resolve(calculateKelly({ true_probability: estimatedProb, market_price: currentPrice, bankroll })),
+      calculateTechnicalIndicators({ token_id: tokenId, prices: priceHistory }).catch(() => null),
+      analyzeVolatility({ token_id: tokenId, prices: priceHistory }).catch(() => null),
+      runMonteCarlo({ positions: [{ token_id: tokenId, current_price: currentPrice, entry_price: currentPrice, size: bankroll }], volatility: priceHistory.length >= 20 ? calculateVolFromPrices(priceHistory) : 0.5, time_horizon_hours: 24 }).catch(() => null),
+      calculateVaR({ positions: [{ token_id: tokenId, size: bankroll, entry_price: currentPrice }] }).catch(() => null),
+      generateCompositeSignal({ token_id: tokenId }).catch(() => null)
+    ]);
+  } else {
+    kellyResult = calculateKelly({ true_probability: estimatedProb, market_price: currentPrice, bankroll });
+  }
+  let twitterResult = null, redditResult = null, velocityResult = null;
+  let oddsResult = null, resolutionResult = null;
+  let resRiskResult = null, counterpartyResult = null;
+  if (!params.skipSlow) {
+    const slowResults = await Promise.all([
+      market.question ? analyzeTwitterSentiment(market.question).catch(() => null) : null,
+      market.question ? monitorRedditPulse(market.question).catch(() => null) : null,
+      market.question ? measureSocialVelocity(market.question).catch(() => null) : null,
+      market.question ? compareOdds(market.question, currentPrice).catch(() => null) : null,
+      marketSlug ? trackResolution(marketSlug).catch(() => null) : null,
+      marketSlug ? assessResolutionRisk(marketSlug).catch(() => null) : null,
+      analyzeCounterparties(tokenId, side).catch(() => null)
+    ]);
+    [twitterResult, redditResult, velocityResult, oddsResult, resolutionResult, resRiskResult, counterpartyResult] = slowResults;
+  }
+  const synthesis = synthesize({
+    currentPrice,
+    estimatedProb,
+    bankroll,
+    kelly: kellyResult,
+    technicals,
+    regime: regimeResult,
+    smartMoney: smartMoneyResult,
+    manipulation: manipulationResult,
+    resRisk: resRiskResult,
+    microstructure: microResult,
+    twitter: twitterResult,
+    reddit: redditResult,
+    compositeSignal,
+    flow: flowResult,
+    whales: whaleResult,
+    orderbook: orderbookResult
+  });
+  return {
+    market,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    screener: null,
+    // screener works on market lists, not single tokens
+    quant: { kelly: kellyResult, technicals, volatility: volatilityResult, monteCarlo: monteCarloResult, var: varResult, compositeSignal },
+    analytics: { regime: regimeResult, smartMoney: smartMoneyResult, microstructure: microResult },
+    onchain: { orderbook: orderbookResult, whales: whaleResult, flow: flowResult },
+    social: { twitter: twitterResult, reddit: redditResult, velocity: velocityResult },
+    feeds: { odds: oddsResult, resolution: resolutionResult },
+    counterintel: { manipulation: manipulationResult, resolutionRisk: resRiskResult, counterparties: counterpartyResult },
+    synthesis
+  };
+}
+function calculateVolFromPrices(prices) {
+  if (prices.length < 2) return 0.5;
+  const returns = [];
+  for (let i = 1; i < prices.length; i++) {
+    if (prices[i - 1] > 0) returns.push(Math.log(prices[i] / prices[i - 1]));
+  }
+  if (returns.length < 2) return 0.5;
+  const mean = returns.reduce((s, r) => s + r, 0) / returns.length;
+  const variance = returns.reduce((s, r) => s + (r - mean) ** 2, 0) / (returns.length - 1);
+  return Math.sqrt(variance * 365);
+}
+function synthesize(data) {
+  const { currentPrice, estimatedProb, bankroll, kelly, technicals, regime, smartMoney, manipulation, resRisk, microstructure, twitter, reddit, compositeSignal, flow, whales, orderbook } = data;
+  let score = 50;
+  const factors = [];
+  const warnings = [];
+  if (kelly?.edge) {
+    const edge = kelly.edge;
+    if (edge > 10) {
+      score += 15;
+      factors.push(`Strong edge: ${edge.toFixed(1)}%`);
+    } else if (edge > 5) {
+      score += 8;
+      factors.push(`Moderate edge: ${edge.toFixed(1)}%`);
+    } else if (edge < -5) {
+      score -= 10;
+      warnings.push(`Negative edge: ${edge.toFixed(1)}%`);
+    }
+  }
+  if (regime) {
+    if (regime.regime === "TRENDING" && regime.trend_direction === "UP") {
+      score += 8;
+      factors.push("Uptrend detected");
+    } else if (regime.regime === "TRENDING" && regime.trend_direction === "DOWN") {
+      score -= 8;
+      warnings.push("Downtrend detected");
+    } else if (regime.regime === "MEAN_REVERTING") {
+      factors.push("Mean-reverting regime \u2014 trade contrarian");
+    }
+  }
+  if (smartMoney) {
+    if (smartMoney.smart_money_index > 0.2) {
+      score += 10;
+      factors.push(`Smart money buying (${smartMoney.smart_money_index.toFixed(2)})`);
+    } else if (smartMoney.smart_money_index < -0.2) {
+      score -= 10;
+      warnings.push(`Smart money selling (${smartMoney.smart_money_index.toFixed(2)})`);
+    }
+  }
+  if (manipulation?.risk_level === "HIGH") {
+    score -= 20;
+    warnings.push("HIGH manipulation risk detected");
+  } else if (manipulation?.risk_level === "MEDIUM") {
+    score -= 8;
+    warnings.push("Moderate manipulation risk");
+  }
+  if (resRisk?.risk_level === "HIGH") {
+    score -= 15;
+    warnings.push("HIGH resolution risk \u2014 potential disputes");
+  }
+  if (twitter?.overall_sentiment > 0.3) {
+    score += 5;
+    factors.push("Positive social sentiment");
+  } else if (twitter?.overall_sentiment < -0.3) {
+    score -= 5;
+    warnings.push("Negative social sentiment");
+  }
+  if (compositeSignal?.signal === "BUY") {
+    score += 8;
+    factors.push("Composite signal: BUY");
+  } else if (compositeSignal?.signal === "SELL") {
+    score -= 8;
+    warnings.push("Composite signal: SELL");
+  }
+  if (flow?.flows?.["1h"]?.signal === "bullish") {
+    score += 5;
+    factors.push("Bullish order flow (1h)");
+  } else if (flow?.flows?.["1h"]?.signal === "bearish") {
+    score -= 5;
+    warnings.push("Bearish order flow (1h)");
+  }
+  if (microstructure?.market_quality === "POOR") {
+    score -= 10;
+    warnings.push("Poor market quality (wide spread)");
+  }
+  score = Math.max(0, Math.min(100, score));
+  const action = score >= 70 ? "STRONG_BUY" : score >= 58 ? "BUY" : score <= 30 ? "STRONG_SELL" : score <= 42 ? "SELL" : "HOLD";
+  const recommended = kelly?.half_kelly_size || 0;
+  const target = Math.min(0.99, currentPrice * 1.15);
+  const stopLoss = Math.max(0.01, currentPrice * 0.8);
+  const riskReward = (target - currentPrice) / (currentPrice - stopLoss) || 0;
+  return {
+    overall_score: score,
+    confidence: factors.length > 3 ? 0.8 : factors.length > 1 ? 0.6 : 0.4,
+    action,
+    recommended_size: +recommended.toFixed(2),
+    entry_price: +currentPrice.toFixed(4),
+    target_price: +target.toFixed(4),
+    stop_loss: +stopLoss.toFixed(4),
+    risk_reward: +riskReward.toFixed(2),
+    key_factors: factors,
+    warnings,
+    thesis: `${action} at ${currentPrice.toFixed(3)} (score ${score}/100). ${factors.slice(0, 3).join(". ")}. ${warnings.length ? "Risks: " + warnings.slice(0, 2).join(", ") : "No major risks."}`
+  };
+}
+async function quickAnalysis(tokenId, marketQuestion, bankroll = 100) {
+  const result = await fullAnalysis({
+    tokenId,
+    marketQuestion,
+    bankroll,
+    skipSlow: true
+  });
+  const orderbook = result.onchain.orderbook ? {
+    spread: result.onchain.orderbook.spread,
+    imbalance: result.onchain.orderbook.imbalance,
+    quality: result.analytics.microstructure?.market_quality || "UNKNOWN"
+  } : { spread: null, imbalance: null, quality: "UNAVAILABLE \u2014 CLOB rate limited, use poly_orderbook_depth later" };
+  return {
+    token_id: tokenId,
+    market: result.market.question,
+    current_price: result.synthesis.entry_price,
+    score: result.synthesis.overall_score,
+    action: result.synthesis.action,
+    kelly: result.quant.kelly || { note: "Insufficient price history for Kelly calculation", recommendation: "Use poly_kelly_criterion directly with your estimated probability" },
+    orderbook,
+    regime: result.analytics.regime?.regime || "UNAVAILABLE",
+    smart_money: result.analytics.smartMoney?.smart_money_index ?? null,
+    manipulation_risk: result.counterintel.manipulation?.risk_level || "UNCHECKED",
+    thesis: result.synthesis.thesis
+  };
+}
+async function batchScreen(params) {
+  return screenMarkets(params);
+}
+async function portfolioReview(params) {
+  const overview = await analyzePortfolio(params.positions);
+  const tokenIds = params.positions.map((p) => p.token_id).slice(0, 10);
+  const correlations = tokenIds.length >= 2 ? await buildCorrelationMatrix(tokenIds).catch(() => null) : null;
+  const kellySizing = calculatePortfolioKelly(
+    params.positions.map((p) => {
+      const pos = overview.positions.find((op) => op.token_id === p.token_id);
+      return { token_id: p.token_id, market: p.market, current_price: pos?.current_price || p.avg_price, estimated_true_prob: pos?.current_price || p.avg_price };
+    }),
+    params.bankroll
+  );
+  const pnlAttribution = params.closedTrades?.length ? attributePnL(params.closedTrades) : null;
+  const recommendations = [];
+  if (!overview.concentration.diversified) recommendations.push("Portfolio is concentrated \u2014 consider diversifying across more markets");
+  if (correlations && correlations.diversification_score < 50) recommendations.push("High correlation between positions \u2014 diversification is poor");
+  if (overview.total_pnl_pct < -15) recommendations.push("Portfolio down >15% \u2014 review thesis for each position");
+  for (const pos of overview.positions) {
+    if (pos.pnl_pct < -25) recommendations.push(`${pos.market}: Down ${Math.abs(pos.pnl_pct)}% \u2014 consider cutting losses`);
+    if (pos.pnl_pct > 50) recommendations.push(`${pos.market}: Up ${pos.pnl_pct}% \u2014 consider taking partial profits`);
+  }
+  return { overview, correlations, kellySizing, pnlAttribution, recommendations };
+}
+
+export {
+  analyzeTwitterSentiment,
+  analyzePolymarketComments,
+  monitorRedditPulse,
+  monitorTelegram,
+  measureSocialVelocity,
+  fetchOfficialSource,
+  compareOdds,
+  trackResolution,
+  fetchBreakingNews,
+  analyzeOrderbookDepth,
+  scanWhaleTrades,
+  analyzeFlow,
+  profileWallet,
+  mapLiquidity,
+  decodeTransaction,
+  getWalletTransactions,
+  findCorrelations,
+  scanArbitrage,
+  detectRegime,
+  calculateSmartMoneyIndex,
+  analyzeMicrostructure,
+  analyzePortfolio,
+  calculatePortfolioKelly,
+  attributePnL,
+  calculateKelly,
+  priceBinaryOption,
+  bayesianUpdate,
+  runMonteCarlo,
+  calculateTechnicalIndicators,
+  analyzeVolatility,
+  analyzeStatArb,
+  calculateVaR,
+  calculateEntropy,
+  analyzeSentiment,
+  fetchNewsFeed,
+  generateCompositeSignal,
+  calculateCorrelationMatrix,
+  testMarketEfficiency,
+  detectManipulation,
+  assessResolutionRisk,
+  analyzeCounterparties,
+  fullAnalysis,
+  quickAnalysis,
+  batchScreen,
+  portfolioReview
+};