kalshi-trading-bot-cli 2.1.0

package/src/risk/gate.ts

@@ -0,0 +1,125 @@
+import type { Database } from 'bun:sqlite';
+import type { KalshiMarket } from '../tools/kalshi/types.js';
+import type { KellyResult } from './kelly.js';
+import { getSpreadCents, getVolume24h } from './kelly.js';
+import { isCorrelated } from './correlation.js';
+import { getOpenPositions } from '../db/positions.js';
+import { getLatestSnapshot } from '../db/risk.js';
+import { getBotSetting } from '../utils/bot-config.js';
+
+export interface RiskConfig {
+  maxSpreadCents?: number;     // default 5
+  minVolume24h?: number;       // default 500
+  maxPerCategory?: number;     // default 3
+  maxTotalPositions?: number;  // default 10
+  maxDrawdownPct?: number;     // default 0.20
+  maxPositionPct?: number;     // default 0.10
+}
+
+export interface RiskGateParams {
+  ticker: string;
+  eventTicker: string;
+  kelly: KellyResult;
+  market: KalshiMarket;
+  db: Database;
+  config?: RiskConfig;
+}
+
+export interface RiskCheck {
+  name: string;
+  passed: boolean;
+  reason: string;
+}
+
+export interface RiskGateResult {
+  passed: boolean;
+  checks: RiskCheck[];
+}
+
+/**
+ * 5-check pre-execution risk gate. All checks must pass.
+ */
+export function riskGate(params: RiskGateParams): RiskGateResult {
+  const { ticker, eventTicker, kelly, market, db, config } = params;
+
+  const maxSpreadCents = config?.maxSpreadCents ?? (getBotSetting('risk.max_spread_cents') as number);
+  const minVolume24h = config?.minVolume24h ?? (getBotSetting('risk.min_volume_24h') as number);
+  const maxPerCategory = config?.maxPerCategory ?? (getBotSetting('risk.max_per_category') as number);
+  const maxTotalPositions = config?.maxTotalPositions ?? (getBotSetting('risk.max_positions') as number);
+  const maxDrawdownPct = config?.maxDrawdownPct ?? (getBotSetting('risk.max_drawdown') as number);
+  const maxPositionPct = config?.maxPositionPct ?? (getBotSetting('risk.max_position_pct') as number);
+
+  const checks: RiskCheck[] = [];
+
+  // 1. Kelly check — contracts > 0 and dollar amount within position limit
+  // Re-check against maxPositionPct independently (kelly.ts uses its own default which may differ)
+  const kellyMaxDollar = Math.floor(kelly.availableBankroll * maxPositionPct);
+  const kellyWithinLimit = kelly.dollarAmountCents <= kellyMaxDollar;
+  const kellyPassed = kelly.contracts > 0 && kellyWithinLimit;
+  checks.push({
+    name: 'kelly',
+    passed: kellyPassed,
+    reason: kelly.contracts === 0
+      ? (kelly.skippedReason
+        ? `Kelly produced 0 contracts: ${kelly.skippedReason}`
+        : `Kelly produced 0 contracts for ${ticker}`)
+      : !kellyWithinLimit
+        ? `Dollar amount $${(kelly.dollarAmountCents / 100).toFixed(2)} exceeds ${maxPositionPct * 100}% of bankroll $${(kelly.availableBankroll / 100).toFixed(2)}`
+        : `${kelly.contracts} ${kelly.side.toUpperCase()} contracts, $${(kelly.dollarAmountCents / 100).toFixed(2)} within limits`,
+  });
+
+  // 2. Liquidity check — spread and volume (using dollar-aware spread)
+  const spreadCents = getSpreadCents(market);
+  const spreadOk = spreadCents < maxSpreadCents;
+  const vol24h = getVolume24h(market);
+  const volumeOk = vol24h >= minVolume24h;
+  const liquidityPassed = spreadOk && volumeOk;
+  checks.push({
+    name: 'liquidity',
+    passed: liquidityPassed,
+    reason: !spreadOk
+      ? `Spread ${spreadCents}¢ >= max ${maxSpreadCents}¢`
+      : !volumeOk
+        ? `24h volume ${vol24h} < min ${minVolume24h}`
+        : `Spread ${spreadCents}¢, volume ${vol24h} OK`,
+  });
+
+  // 3. Correlation check — category concentration
+  const correlated = isCorrelated(eventTicker, db, maxPerCategory);
+  checks.push({
+    name: 'correlation',
+    passed: !correlated,
+    reason: correlated
+      ? `Category for ${eventTicker} already has ${maxPerCategory}+ open positions`
+      : `Category concentration within limit`,
+  });
+
+  // 4. Concentration check — total open positions
+  const openPositions = getOpenPositions(db);
+  const concentrationPassed = openPositions.length < maxTotalPositions;
+  checks.push({
+    name: 'concentration',
+    passed: concentrationPassed,
+    reason: concentrationPassed
+      ? `${openPositions.length} open positions < max ${maxTotalPositions}`
+      : `${openPositions.length} open positions >= max ${maxTotalPositions}`,
+  });
+
+  // 5. Drawdown check — current drawdown vs limit
+  const snapshot = getLatestSnapshot(db);
+  const drawdownPassed = snapshot?.drawdown_current == null || snapshot.drawdown_current < maxDrawdownPct;
+  checks.push({
+    name: 'drawdown',
+    passed: drawdownPassed,
+    reason: snapshot?.drawdown_current == null
+      ? 'No snapshot yet — first trade allowed'
+      : snapshot.drawdown_current < maxDrawdownPct
+        ? `Drawdown ${(snapshot.drawdown_current * 100).toFixed(1)}% < max ${maxDrawdownPct * 100}%`
+        : `Drawdown ${(snapshot.drawdown_current * 100).toFixed(1)}% >= max ${maxDrawdownPct * 100}%`,
+  });
+
+  return {
+    passed: checks.every((c) => c.passed),
+    checks,
+  };
+}

package/src/risk/index.ts

@@ -0,0 +1,10 @@
+export { kellySize, fetchLiveBankroll, getSpreadCents, getVolume24h } from './kelly.js';
+export type { KellySizeParams, KellyResult, LiveBankroll } from './kelly.js';
+
+export { riskGate } from './gate.js';
+export type { RiskGateParams, RiskGateResult, RiskCheck, RiskConfig } from './gate.js';
+
+export { getCorrelationByCategory, isCorrelated } from './correlation.js';
+
+export { CircuitBreaker } from './circuit-breaker.js';
+export type { CircuitBreakerConfig, CircuitBreakerStatus } from './circuit-breaker.js';

package/src/risk/kelly.ts

@@ -0,0 +1,230 @@
+import { callKalshiApi, supportsFractional } from "../tools/kalshi/api.js";
+import type {
+  KalshiBalance,
+  KalshiMarket,
+  KalshiPosition,
+} from "../tools/kalshi/types.js";
+import { getBotSetting } from "../utils/bot-config.js";
+
+export interface KellySizeParams {
+  edge: number; // octagon_prob - market_prob (signed)
+  marketProb: number; // current Kalshi market probability
+  multiplier?: number; // Kelly fraction, default 0.5 (half-Kelly)
+  maxPositionPct?: number; // max % of bankroll per position, default 0.10
+  minEdgeThreshold?: number; // min absolute edge to size, default 0.05 (5%)
+  market?: KalshiMarket; // for liquidity adjustment (spread, volume)
+}
+
+export interface KellyResult {
+  side: 'yes' | 'no'; // which side to buy
+  fraction: number; // raw Kelly fraction (before multiplier)
+  adjustedFraction: number; // after multiplier + liquidity adj
+  contracts: number; // rounded to supported increment
+  dollarAmountCents: number; // contracts * entry price in cents
+  entryPriceCents: number; // actual entry price used (ask, not midpoint)
+  availableBankroll: number; // cash - open exposure (cents)
+  openExposure: number; // sum of market_exposure from positions (cents)
+  cashBalance: number; // cents
+  portfolioValue: number; // cents
+  liquidityAdjusted: boolean;
+  skippedReason?: string; // if contracts=0, explains why
+}
+
+export interface LiveBankroll {
+  cashBalance: number; // cents
+  portfolioValue: number; // cents
+  openExposure: number; // cents
+  availableBankroll: number; // cents
+}
+
+/**
+ * Fetch live bankroll from Kalshi API.
+ * Returns balances and open exposure in cents.
+ */
+export async function fetchLiveBankroll(): Promise<LiveBankroll> {
+  const balanceRes = await callKalshiApi("GET", "/portfolio/balance");
+  const balance = balanceRes as unknown as KalshiBalance;
+
+  const positionsRes = await callKalshiApi("GET", "/portfolio/positions");
+  const positions = (positionsRes.market_positions ??
+    positionsRes.positions ??
+    []) as KalshiPosition[];
+
+  const cashBalance = balance.balance;
+  const portfolioValue = balance.portfolio_value;
+  const openExposure = positions.reduce((sum, p) => {
+    if (p.market_exposure_dollars != null) {
+      const parsed = parseFloat(String(p.market_exposure_dollars).trim());
+      if (Number.isFinite(parsed)) {
+        return sum + Math.round(parsed * 100);
+      }
+    }
+    return sum + (p.market_exposure ?? 0);
+  }, 0);
+  const availableBankroll = Math.max(0, cashBalance - openExposure);
+
+  return { cashBalance, portfolioValue, openExposure, availableBankroll };
+}
+
+/** Parse a dollar-string or integer-cent price field to a decimal (0-1). */
+function parsePriceField(dollarStr: string | undefined, legacyDollarStr: string | undefined, centVal: number | undefined): number {
+  const d = dollarStr != null ? parseFloat(dollarStr) : legacyDollarStr != null ? parseFloat(legacyDollarStr) : NaN;
+  if (Number.isFinite(d)) return d;
+  if (centVal != null && Number.isFinite(centVal)) return centVal / 100;
+  return NaN;
+}
+
+/** Get 24h volume from a market, handling both volume_24h_fp (string) and legacy volume_24h (number). */
+export function getVolume24h(market: KalshiMarket): number {
+  if (market.volume_24h_fp != null) {
+    const v = parseFloat(market.volume_24h_fp);
+    if (Number.isFinite(v)) return v;
+  }
+  if (market.volume_24h != null && Number.isFinite(market.volume_24h)) return market.volume_24h;
+  return 0;
+}
+
+/** Get the bid/ask spread in cents from a market, handling dollar-string fields. */
+export function getSpreadCents(market: KalshiMarket): number {
+  const bid = parsePriceField(market.yes_bid_dollars, market.dollar_yes_bid, market.yes_bid);
+  const ask = parsePriceField(market.yes_ask_dollars, market.dollar_yes_ask, market.yes_ask);
+  if (Number.isFinite(bid) && Number.isFinite(ask)) return Math.round((ask - bid) * 100);
+  return 99; // unknown spread → treat as very wide
+}
+
+/**
+ * Compute Kelly-optimal position size using live Kalshi portfolio data.
+ * All amounts in cents (Kalshi's native unit).
+ *
+ * For YES bets (edge > 0): f* = edge / (1 - marketProb)
+ * For NO bets  (edge < 0): f* = |edge| / marketProb
+ */
+export async function kellySize(params: KellySizeParams): Promise<KellyResult> {
+  const { edge, marketProb, market } = params;
+  const multiplier = params.multiplier ?? (getBotSetting('risk.kelly_multiplier') as number);
+  const maxPositionPct = params.maxPositionPct ?? (getBotSetting('risk.max_position_pct') as number);
+  const minEdgeThreshold = params.minEdgeThreshold ?? (getBotSetting('risk.min_edge_threshold') as number);
+
+  const bankroll = await fetchLiveBankroll();
+  const { cashBalance, portfolioValue, openExposure, availableBankroll } =
+    bankroll;
+
+  const side: 'yes' | 'no' = edge >= 0 ? 'yes' : 'no';
+
+  // Compute executable probability from the ask price we'd actually trade at.
+  // YES buy → yes_ask; NO buy → no_ask expressed as YES-equivalent (1 - no_ask)
+  let executableProb: number | null = null;
+  if (market) {
+    if (side === 'yes') {
+      const ask = parsePriceField(market.yes_ask_dollars, market.dollar_yes_ask, market.yes_ask);
+      if (Number.isFinite(ask) && ask > 0) executableProb = ask;
+    } else {
+      const noAsk = parsePriceField(market.no_ask_dollars, market.dollar_no_ask, market.no_ask);
+      if (Number.isFinite(noAsk) && noAsk > 0) executableProb = 1 - noAsk;
+    }
+  }
+  // Fall back to midpoint if no executable quote is available
+  const pricingProb = executableProb ?? marketProb;
+
+  // Recompute edge relative to executable quote to avoid overstating edge;
+  // when no executable quote is available, use the original edge directly
+  // to avoid floating-point roundtrip error from (marketProb + edge) - marketProb.
+  const executableEdge = executableProb != null
+    ? (marketProb + edge) - executableProb
+    : edge;
+  const absEdge = Math.abs(executableEdge);
+
+  // Entry price from executable quote — computed early so it's available even when sizing is skipped
+  let entryPriceCents: number;
+  if (side === 'yes') {
+    entryPriceCents = executableProb != null ? Math.round(executableProb * 100) : Math.round(marketProb * 100);
+  } else {
+    entryPriceCents = executableProb != null ? Math.round((1 - executableProb) * 100) : Math.round((1 - marketProb) * 100);
+  }
+
+  const makeResult = (overrides: Partial<KellyResult> = {}): KellyResult => ({
+    side,
+    fraction: 0,
+    adjustedFraction: 0,
+    contracts: 0,
+    dollarAmountCents: 0,
+    entryPriceCents,
+    availableBankroll,
+    openExposure,
+    cashBalance,
+    portfolioValue,
+    liquidityAdjusted: false,
+    ...overrides,
+  });
+
+  // Minimum edge threshold — don't size if edge is within model error
+  if (absEdge < minEdgeThreshold) {
+    return makeResult({ skippedReason: `Edge ${(absEdge * 100).toFixed(1)}% below ${(minEdgeThreshold * 100).toFixed(0)}% threshold` });
+  }
+
+  // Guard against extreme probabilities that would cause division by zero
+  if (pricingProb <= 0 || pricingProb >= 1) {
+    return makeResult({ skippedReason: 'Extreme probability — cannot size' });
+  }
+
+  // Kelly formula for binary outcome using executable quote
+  // YES: f* = executableEdge / (1 - pricingProb)  — cost is pricingProb, payoff is (1 - pricingProb)
+  // NO:  f* = |executableEdge| / pricingProb       — cost is (1 - pricingProb), payoff is pricingProb
+  const fraction = side === 'yes'
+    ? executableEdge / (1 - pricingProb)
+    : absEdge / pricingProb;
+
+  let adjustedFraction = fraction * multiplier;
+  let liquidityAdjusted = false;
+
+  // Liquidity adjustment: wide spread or low volume → apply haircut
+  if (market) {
+    const spreadCents = getSpreadCents(market);
+    const liqSpreadThreshold = getBotSetting('risk.liquidity_spread_threshold') as number;
+    const liqVolumeThreshold = getBotSetting('risk.liquidity_volume_threshold') as number;
+    const liqHaircut = getBotSetting('risk.liquidity_haircut') as number;
+    if (spreadCents > liqSpreadThreshold || getVolume24h(market) < liqVolumeThreshold) {
+      adjustedFraction *= liqHaircut;
+      liquidityAdjusted = true;
+    }
+  }
+
+  // Dollar amount before position cap
+  let dollarAmountCents = Math.floor(adjustedFraction * availableBankroll);
+
+  // Cap at maxPositionPct of available bankroll
+  const maxDollar = Math.floor(maxPositionPct * availableBankroll);
+  dollarAmountCents = Math.min(dollarAmountCents, maxDollar);
+
+  let contracts = 0;
+  if (entryPriceCents > 0 && dollarAmountCents > 0) {
+    if (market && supportsFractional(market) && market.tick_size > 0) {
+      const rawContracts = dollarAmountCents / entryPriceCents;
+      contracts =
+        Math.floor(rawContracts / market.tick_size) * market.tick_size;
+    } else {
+      contracts = Math.floor(dollarAmountCents / entryPriceCents);
+    }
+  }
+
+  const skippedReason = contracts === 0
+    ? (availableBankroll === 0
+      ? 'No available bankroll'
+      : entryPriceCents === 0
+        ? 'Entry price rounds to zero'
+        : 'Position too small for bankroll size')
+    : undefined;
+
+  // Recalculate dollar amount based on actual contracts
+  dollarAmountCents = contracts * entryPriceCents;
+
+  return makeResult({
+    fraction,
+    adjustedFraction,
+    contracts,
+    dollarAmountCents,
+    entryPriceCents,
+    liquidityAdjusted,
+    skippedReason,
+  });
+}

package/src/scan/alerter.ts

@@ -0,0 +1,64 @@
+import type { Database } from 'bun:sqlite';
+import type { AuditTrail } from '../audit/trail.js';
+import { createAlert, markAlertSent } from '../db/alerts.js';
+
+export type AlertType =
+  | 'EDGE_DETECTED'
+  | 'CONVERGENCE'
+  | 'ADVERSE_MOVE'
+  | 'EXPIRY_APPROACHING'
+  | 'CATALYST_APPROACHING'
+  | 'CIRCUIT_BREAKER';
+
+export interface AlertPayload {
+  ticker: string;
+  alertType: AlertType;
+  edge: number;
+  message: string;
+  channels: string[];
+}
+
+export type AlertChannelDispatch = (channel: string, alert: AlertPayload) => Promise<void>;
+
+export class Alerter {
+  private db: Database;
+  private audit: AuditTrail;
+  private dispatch?: AlertChannelDispatch;
+
+  constructor(db: Database, audit: AuditTrail, dispatch?: AlertChannelDispatch) {
+    this.db = db;
+    this.audit = audit;
+    this.dispatch = dispatch;
+  }
+
+  async emit(alert: AlertPayload): Promise<void> {
+    const alertId = crypto.randomUUID();
+
+    createAlert(this.db, {
+      alert_id: alertId,
+      ticker: alert.ticker,
+      alert_type: alert.alertType,
+      edge: alert.edge,
+      message: alert.message,
+      channels: JSON.stringify(alert.channels),
+      status: 'pending',
+      created_at: Math.floor(Date.now() / 1000),
+    });
+
+    for (const channel of alert.channels) {
+      if (this.dispatch) {
+        await this.dispatch(channel, alert);
+      } else if (channel === 'terminal') {
+        console.log(`[ALERT] [${alert.alertType}] ${alert.ticker}: ${alert.message} (edge=${alert.edge.toFixed(4)})`);
+      }
+    }
+
+    markAlertSent(this.db, alertId);
+
+    this.audit.log({
+      type: 'ALERT_SENT',
+      alert_id: alertId,
+      channels: alert.channels,
+    });
+  }
+}

package/src/scan/edge-computer.ts

@@ -0,0 +1,164 @@
+import type { Database } from 'bun:sqlite';
+import type { AuditTrail } from '../audit/trail.js';
+import { callKalshiApi } from '../tools/kalshi/api.js';
+import type { KalshiMarket } from '../tools/kalshi/types.js';
+import { insertEdge } from '../db/edge.js';
+import { OctagonClient } from './octagon-client.js';
+import type { OctagonReport, OctagonVariant, ConfidenceLevel, EdgeSnapshot } from './types.js';
+import { isMarketActive, parseMarketProb } from '../controllers/browse.js';
+
+const OCTAGON_CONCURRENCY = (() => {
+  const parsed = parseInt(process.env.OCTAGON_CONCURRENCY ?? '5', 10);
+  return Number.isFinite(parsed) && parsed >= 1 ? parsed : 5;
+})();
+
+export class EdgeComputer {
+  private db: Database;
+  private audit: AuditTrail;
+
+  constructor(db: Database, audit: AuditTrail) {
+    this.db = db;
+    this.audit = audit;
+  }
+
+  classifyConfidence(absEdge: number): ConfidenceLevel {
+    if (absEdge >= 0.10) return 'very_high';
+    if (absEdge >= 0.05) return 'high';
+    if (absEdge >= 0.02) return 'moderate';
+    return 'low';
+  }
+
+  computeEdge(ticker: string, octagonReport: OctagonReport, marketProb: number): EdgeSnapshot {
+    const edge = octagonReport.modelProb - marketProb;
+    const confidence = this.classifyConfidence(Math.abs(edge));
+
+    return {
+      ticker,
+      eventTicker: octagonReport.eventTicker,
+      modelProb: octagonReport.modelProb,
+      marketProb,
+      edge,
+      confidence,
+      drivers: octagonReport.drivers,
+      catalysts: octagonReport.catalysts,
+      sources: octagonReport.sources,
+      octagonReportId: `${octagonReport.ticker}-${octagonReport.fetchedAt}`,
+      cacheHit: octagonReport.variantUsed === 'cache',
+      timestamp: Math.floor(Date.now() / 1000),
+    };
+  }
+
+  async computeAll(tickers: string[], octagonClient: OctagonClient): Promise<EdgeSnapshot[]> {
+    const snapshots: EdgeSnapshot[] = [];
+
+    // Phase A: Collect all market tasks (Kalshi API calls are fast, keep sequential for rate limits)
+    interface MarketTask {
+      market: KalshiMarket;
+      eventTicker: string;
+      marketProb: number;
+      variant: OctagonVariant;
+    }
+    const tasks: MarketTask[] = [];
+
+    for (const eventTicker of tickers) {
+      try {
+        const response = await callKalshiApi('GET', `/events/${eventTicker}`, {
+          params: { with_nested_markets: true },
+        });
+
+        const event = response.event as { markets?: KalshiMarket[] } | undefined;
+        const markets = (event?.markets ?? response.markets ?? []) as KalshiMarket[];
+
+        for (const market of markets) {
+          if (!isMarketActive(market)) continue;
+          const marketProb = parseMarketProb(market);
+          if (marketProb === null) continue; // no last traded price — skip
+          const { refresh } = octagonClient.shouldRefresh(market.ticker, marketProb, false, market.close_time);
+          tasks.push({ market, eventTicker, marketProb, variant: refresh ? 'refresh' : 'cache' });
+        }
+      } catch (err) {
+        this.audit.log({
+          type: 'OCTAGON_ERROR',
+          ticker: eventTicker,
+          event_ticker: eventTicker,
+          error: String(err instanceof Error ? err.message : err),
+        });
+        continue;
+      }
+    }
+
+    // Phase B: Process Octagon calls in parallel batches
+    // Reserve credits synchronously before fanning out to prevent concurrent
+    // refresh calls from overshooting the daily credit ceiling.
+    for (let i = 0; i < tasks.length; i += OCTAGON_CONCURRENCY) {
+      const batch = tasks.slice(i, i + OCTAGON_CONCURRENCY);
+
+      // Reserve credits synchronously per-task before async fan-out
+      const reservedBatch = batch.map((task) => ({
+        ...task,
+        reservedVariant: octagonClient.reserveRefresh(task.variant),
+      }));
+
+      const results = await Promise.allSettled(
+        reservedBatch.map(async (task) => {
+          // Try prefetch first to avoid individual cache API calls
+          const prefetched = task.reservedVariant === 'cache'
+            ? octagonClient.tryFromPrefetch(task.market.ticker, task.eventTicker, task.market.close_time)
+            : null;
+          const report = prefetched ?? await octagonClient.fetchReport(
+            task.market.ticker, task.eventTicker, task.reservedVariant,
+            { creditsPreReserved: true, closeTimeIso: task.market.close_time },
+          );
+          return { task, report };
+        }),
+      );
+
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'rejected') {
+          const failedTask = reservedBatch[i];
+          this.audit.log({
+            type: 'OCTAGON_ERROR',
+            ticker: failedTask.market.ticker,
+            event_ticker: failedTask.eventTicker,
+            error: String(result.reason),
+          });
+          continue;
+        }
+        const { task, report } = result.value;
+        const snapshot = this.computeEdge(task.market.ticker, report, task.marketProb);
+        snapshots.push(snapshot);
+
+        insertEdge(this.db, {
+          ticker: snapshot.ticker,
+          event_ticker: snapshot.eventTicker,
+          timestamp: snapshot.timestamp,
+          model_prob: snapshot.modelProb,
+          market_prob: snapshot.marketProb,
+          edge: snapshot.edge,
+          octagon_report_id: snapshot.octagonReportId,
+          drivers_json: JSON.stringify(snapshot.drivers),
+          sources_json: JSON.stringify(snapshot.sources),
+          catalysts_json: JSON.stringify(snapshot.catalysts),
+          cache_hit: snapshot.cacheHit ? 1 : 0,
+          cache_miss: report.cacheMiss ? 1 : 0,
+          confidence: snapshot.confidence,
+        });
+
+        if (Math.abs(snapshot.edge) >= 0.02) {
+          this.audit.log({
+            type: 'EDGE_DETECTED',
+            ticker: snapshot.ticker,
+            model_prob: snapshot.modelProb,
+            market_prob: snapshot.marketProb,
+            edge: snapshot.edge,
+            confidence: snapshot.confidence,
+            drivers: snapshot.drivers.map((d) => d.claim),
+          });
+        }
+      }
+    }
+
+    return snapshots;
+  }
+}