kalshi-trading-bot-cli 2.1.0

package/src/db/event-index.ts

@@ -0,0 +1,323 @@
+import type { Database } from 'bun:sqlite';
+import type { KalshiEvent, KalshiMarket } from '../tools/kalshi/types.js';
+
+export interface IndexedEvent {
+  event_ticker: string;
+  series_ticker: string | null;
+  title: string;
+  category: string | null;
+  strike_date: string | null;
+  sub_title: string | null;
+  tags: string | null;
+  markets_json: string | null;
+  indexed_at: number;
+}
+
+/**
+ * Search the local event index using keyword matching.
+ * All keywords must match against title, event_ticker, series_ticker, or category.
+ * Returns up to `limit` results.
+ */
+export function searchEventIndex(db: Database, query: string, limit = 50): IndexedEvent[] {
+  const keywords = query
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((k) => k.length > 0);
+
+  if (keywords.length === 0) return [];
+
+  // Build WHERE clause: each keyword must match somewhere in the searchable fields
+  const conditions = keywords.map((_, i) => `(search_text LIKE $kw${i})`);
+  const whereClause = conditions.join(' AND ');
+
+  const params: Record<string, string | number> = { $limit: limit, $now: new Date().toISOString() };
+  keywords.forEach((kw, i) => {
+    params[`$kw${i}`] = `%${kw}%`;
+  });
+
+  // Use a CTE to compute search_text, filter expired markets, and rank by open-market volume descending
+  const fullSql = `
+    WITH indexed AS (
+      SELECT *,
+        lower(title) || ' ' || lower(coalesce(event_ticker,'')) || ' ' || lower(coalesce(series_ticker,'')) || ' ' || lower(coalesce(category,'')) || ' ' || lower(coalesce(sub_title,'')) || ' ' || lower(coalesce(tags,'')) AS search_text
+      FROM event_index
+    ),
+    matched AS (
+      SELECT event_ticker, series_ticker, title, category, strike_date, sub_title, tags, markets_json, indexed_at
+      FROM indexed
+      WHERE ${whereClause}
+    )
+    SELECT *
+    FROM matched
+    ORDER BY (
+      SELECT coalesce(sum(
+        CASE WHEN json_extract(value, '$.status') IN ('open','active')
+              AND (json_extract(value, '$.close_time') IS NULL OR json_extract(value, '$.close_time') > $now)
+             THEN json_extract(value, '$.volume')
+             ELSE 0
+        END
+      ), 0)
+      FROM json_each(markets_json)
+    ) DESC
+    LIMIT $limit
+  `;
+
+  return db.query(fullSql).all(params) as IndexedEvent[];
+}
+
+/**
+ * Clear and repopulate the event index in a single transaction.
+ */
+export function clearAndPopulateIndex(
+  db: Database,
+  events: Array<{
+    event_ticker: string;
+    series_ticker?: string;
+    title: string;
+    category?: string;
+    strike_date?: string;
+    sub_title?: string;
+    tags?: string[];
+    markets?: KalshiMarket[];
+  }>,
+  lastPriceMap?: Map<string, { last_price?: number; dollar_last_price?: string; volume_24h_fp?: string }>,
+): void {
+  const now = Date.now();
+
+  const insert = db.prepare(`
+    INSERT INTO event_index (event_ticker, series_ticker, title, category, strike_date, sub_title, tags, markets_json, indexed_at)
+    VALUES ($event_ticker, $series_ticker, $title, $category, $strike_date, $sub_title, $tags, $markets_json, $indexed_at)
+  `);
+
+  db.transaction(() => {
+    db.exec('DELETE FROM event_index');
+
+    for (const event of events) {
+      const compactMarkets = event.markets?.map((m) => {
+        const ticker = m.ticker as string;
+        const priceData = lastPriceMap?.get(ticker);
+        return {
+          ticker,
+          title: m.title,
+          yes_sub_title: m.yes_sub_title,
+          yes_bid: m.yes_bid,
+          yes_ask: m.yes_ask,
+          yes_bid_dollars: m.yes_bid_dollars,
+          yes_ask_dollars: m.yes_ask_dollars,
+          no_bid: m.no_bid,
+          no_ask: m.no_ask,
+          no_bid_dollars: m.no_bid_dollars,
+          no_ask_dollars: m.no_ask_dollars,
+          last_price: priceData?.last_price ?? m.last_price,
+          last_price_dollars: priceData?.dollar_last_price ?? m.last_price_dollars,
+          dollar_last_price: priceData?.dollar_last_price ?? m.dollar_last_price,
+          volume: m.volume_fp ?? m.volume ?? 0,
+          volume_24h: parseFloat(priceData?.volume_24h_fp ?? String(m.volume_24h_fp ?? m.volume_24h ?? 0)),
+          close_time: m.close_time,
+          status: m.status,
+          result: m.result,
+        };
+      });
+
+      insert.run({
+        $event_ticker: event.event_ticker,
+        $series_ticker: event.series_ticker ?? null,
+        $title: event.title,
+        $category: event.category ?? null,
+        $strike_date: event.strike_date ?? null,
+        $sub_title: event.sub_title ?? null,
+        $tags: event.tags?.length ? event.tags.join(',') : null,
+        $markets_json: compactMarkets ? JSON.stringify(compactMarkets) : null,
+        $indexed_at: now,
+      });
+    }
+  })();
+}
+
+/**
+ * Enrich existing index rows with market price/volume data from the API.
+ * Groups market data by event_ticker and upserts markets_json for each event,
+ * creating it from scratch if it was NULL (e.g. after Phase 1 index build).
+ */
+export function enrichIndexPrices(
+  db: Database,
+  priceMap: Map<string, { last_price?: number; dollar_last_price?: string; volume_24h_fp?: string }>,
+  marketsByEvent?: Map<string, Array<Record<string, unknown>>>,
+): void {
+  if (priceMap.size === 0 && (!marketsByEvent || marketsByEvent.size === 0)) return;
+
+  const update = db.prepare('UPDATE event_index SET markets_json = $markets_json WHERE event_ticker = $event_ticker');
+
+  db.transaction(() => {
+    if (marketsByEvent) {
+      // Build markets_json from full market data, enriched with prices
+      for (const [eventTicker, markets] of marketsByEvent) {
+        const compactMarkets = markets.map((m) => {
+          const ticker = m.ticker as string;
+          const priceData = priceMap.get(ticker);
+          return {
+            ticker,
+            title: m.title,
+            yes_sub_title: m.yes_sub_title,
+            yes_bid: m.yes_bid,
+            yes_ask: m.yes_ask,
+            yes_bid_dollars: m.yes_bid_dollars,
+            yes_ask_dollars: m.yes_ask_dollars,
+            no_bid: m.no_bid,
+            no_ask: m.no_ask,
+            no_bid_dollars: m.no_bid_dollars,
+            no_ask_dollars: m.no_ask_dollars,
+            last_price: priceData?.last_price ?? m.last_price,
+            dollar_last_price: priceData?.dollar_last_price ?? m.dollar_last_price,
+            last_price_dollars: priceData?.dollar_last_price ?? m.last_price_dollars,
+            volume: m.volume_fp ?? m.volume ?? 0,
+            volume_24h: parseFloat(priceData?.volume_24h_fp ?? String(m.volume_24h_fp ?? m.volume_24h ?? 0)),
+            close_time: m.close_time,
+            status: m.status,
+            result: m.result,
+          };
+        });
+        update.run({ $markets_json: JSON.stringify(compactMarkets), $event_ticker: eventTicker });
+      }
+    } else {
+      // Fallback: update existing markets_json rows with price data
+      const rows = db.query('SELECT event_ticker, markets_json FROM event_index WHERE markets_json IS NOT NULL').all() as Array<{
+        event_ticker: string;
+        markets_json: string;
+      }>;
+
+      for (const row of rows) {
+        let markets: Array<Record<string, unknown>>;
+        try {
+          markets = JSON.parse(row.markets_json);
+        } catch {
+          continue;
+        }
+
+        let changed = false;
+        for (const m of markets) {
+          const ticker = m.ticker as string;
+          const priceData = priceMap.get(ticker);
+          if (!priceData) continue;
+          if (priceData.last_price != null) m.last_price = priceData.last_price;
+          if (priceData.dollar_last_price != null) m.dollar_last_price = priceData.dollar_last_price;
+          if (priceData.volume_24h_fp != null) m.volume_24h = parseFloat(priceData.volume_24h_fp);
+          changed = true;
+        }
+
+        if (changed) {
+          update.run({ $markets_json: JSON.stringify(markets), $event_ticker: row.event_ticker });
+        }
+      }
+    }
+  })();
+}
+
+/**
+ * Get the timestamp of the last successful index refresh, or null if never refreshed.
+ */
+export function getLastRefresh(db: Database): number | null {
+  const row = db.query("SELECT value FROM event_index_meta WHERE key = 'last_refresh'").get() as
+    | { value: string }
+    | null;
+  return row ? parseInt(row.value, 10) : null;
+}
+
+/**
+ * Set the last refresh timestamp.
+ */
+export function setLastRefresh(db: Database, timestamp: number): void {
+  db.query("INSERT OR REPLACE INTO event_index_meta (key, value) VALUES ('last_refresh', $ts)").run({
+    $ts: String(timestamp),
+  });
+}
+
+/**
+ * Reconstruct KalshiEvent[] from the local index for given event tickers.
+ * Parses markets_json back into nested market objects.
+ */
+export function getEventsFromIndex(db: Database, eventTickers: string[]): KalshiEvent[] {
+  if (eventTickers.length === 0) return [];
+
+  const placeholders = eventTickers.map(() => '?').join(',');
+  const rows = db
+    .query(
+      `SELECT event_ticker, series_ticker, title, category, strike_date, sub_title, markets_json
+       FROM event_index
+       WHERE event_ticker IN (${placeholders})`,
+    )
+    .all(...eventTickers) as IndexedEvent[];
+
+  return rows
+    .map((r) => {
+      let markets: unknown[] = [];
+      try {
+        markets = r.markets_json ? JSON.parse(r.markets_json) : [];
+      } catch {
+        // Corrupted markets_json — skip markets for this event
+      }
+      return {
+        event_ticker: r.event_ticker,
+        series_ticker: r.series_ticker ?? '',
+        title: r.title,
+        category: r.category ?? '',
+        sub_title: r.sub_title ?? '',
+        strike_date: r.strike_date ?? '',
+        mutually_exclusive: false,
+        markets,
+      } as KalshiEvent;
+    });
+}
+
+/**
+ * Get top N events by total market volume from the index.
+ * Parses markets_json, sums volume per event, sorts descending.
+ */
+export function getTopEventsByVolume(db: Database, limit: number): KalshiEvent[] {
+  const rows = db
+    .query(
+      `SELECT event_ticker, series_ticker, title, category, strike_date, sub_title, markets_json
+       FROM event_index
+       WHERE markets_json IS NOT NULL`,
+    )
+    .all() as IndexedEvent[];
+
+  const events: Array<{ event: KalshiEvent; totalVolume: number }> = [];
+  for (const r of rows) {
+    let markets: any[] = [];
+    try {
+      markets = r.markets_json ? JSON.parse(r.markets_json) : [];
+    } catch {
+      // Corrupted markets_json — treat as no markets
+    }
+    const totalVolume = markets.reduce(
+      (sum: number, m: any) => sum + (parseFloat(m.volume) || parseFloat(m.volume_fp) || 0),
+      0,
+    );
+    events.push({
+      event: {
+        event_ticker: r.event_ticker,
+        series_ticker: r.series_ticker ?? '',
+        title: r.title,
+        category: r.category ?? '',
+        sub_title: r.sub_title ?? '',
+        strike_date: r.strike_date ?? '',
+        mutually_exclusive: false,
+        markets,
+      } as KalshiEvent,
+      totalVolume,
+    });
+  }
+
+  events.sort((a, b) => b.totalVolume - a.totalVolume);
+  return events.slice(0, limit).map((e) => e.event);
+}
+
+/**
+ * Get the age of the index in milliseconds, or Infinity if never refreshed.
+ */
+export function getIndexAge(db: Database): number {
+  const last = getLastRefresh(db);
+  if (last === null) return Infinity;
+  return Date.now() - last;
+}

package/src/db/events.ts

@@ -0,0 +1,41 @@
+import type { Database } from 'bun:sqlite';
+
+export interface Event {
+  ticker: string;
+  category?: string | null;
+  expiry?: number | null;
+  vol_24h?: number | null;
+  theme_id?: string | null;
+  active?: number | null;
+  updated_at?: number | null;
+}
+
+export function upsertEvent(db: Database, event: Event): void {
+  db.prepare(`
+    INSERT OR REPLACE INTO events (ticker, category, expiry, vol_24h, theme_id, active, updated_at)
+    VALUES ($ticker, $category, $expiry, $vol_24h, $theme_id, $active, $updated_at)
+  `).run({
+    $ticker: event.ticker,
+    $category: event.category ?? null,
+    $expiry: event.expiry ?? null,
+    $vol_24h: event.vol_24h ?? null,
+    $theme_id: event.theme_id ?? null,
+    $active: event.active ?? 1,
+    $updated_at: event.updated_at ?? null,
+  });
+}
+
+export function getActiveEvents(db: Database): Event[] {
+  return db.query('SELECT * FROM events WHERE active = 1').all() as Event[];
+}
+
+export function getEvent(db: Database, ticker: string): Event | null {
+  return db.query('SELECT * FROM events WHERE ticker = $ticker').get({ $ticker: ticker }) as Event | null;
+}
+
+export function deactivateExpired(db: Database, cutoffTimestamp: number): number {
+  const result = db.prepare(
+    'UPDATE events SET active = 0 WHERE expiry < $cutoff AND active = 1'
+  ).run({ $cutoff: cutoffTimestamp });
+  return result.changes;
+}

package/src/db/index.ts

@@ -0,0 +1,60 @@
+import { Database } from 'bun:sqlite';
+import { mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { migrate } from './schema.js';
+import { appPath } from '../utils/paths.js';
+import { prefetchOctagonEvents } from '../scan/octagon-prefetch.js';
+
+let _db: Database | null = null;
+
+const DEFAULT_DB_PATH = appPath('kalshi-bot.db');
+
+/**
+ * Get the database singleton. Lazy-initializes on first call.
+ * Pass a custom path for testing (e.g. ":memory:").
+ */
+export function getDb(path?: string): Database {
+  if (_db) return _db;
+
+  const dbPath = path ?? DEFAULT_DB_PATH;
+
+  if (dbPath !== ':memory:') {
+    mkdirSync(dirname(dbPath), { recursive: true });
+  }
+
+  _db = new Database(dbPath);
+  _db.exec('PRAGMA journal_mode = WAL');
+  _db.exec('PRAGMA foreign_keys = ON');
+  migrate(_db);
+
+  // Fire-and-forget: prefetch Octagon events in background (only for the real runtime DB)
+  if (dbPath === DEFAULT_DB_PATH) {
+    const db = _db;
+    prefetchOctagonEvents(db).catch(() => {});
+  }
+
+  return _db;
+}
+
+/**
+ * Close the database singleton and release the file descriptor.
+ * Safe to call even if no DB is open.
+ */
+export function closeDb(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+
+/**
+ * Create a fresh database instance (not the singleton).
+ * Useful for tests with :memory: databases.
+ */
+export function createDb(path: string): Database {
+  const db = new Database(path);
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA foreign_keys = ON');
+  migrate(db);
+  return db;
+}

package/src/db/octagon-cache.ts

@@ -0,0 +1,118 @@
+import type { Database } from 'bun:sqlite';
+
+export interface OctagonReport {
+  report_id: string;
+  ticker: string;
+  event_ticker: string;
+  model_prob: number;
+  market_prob?: number | null;
+  mispricing_signal?: string | null;
+  drivers_json?: string | null;
+  catalysts_json?: string | null;
+  sources_json?: string | null;
+  resolution_history_json?: string | null;
+  contract_snapshot_json?: string | null;
+  raw_response?: string | null;
+  model_accuracy?: number | null;
+  variant_used?: string | null;
+  fetched_at: number;
+  expires_at: number;
+}
+
+export function insertReport(db: Database, report: OctagonReport): void {
+  db.prepare(`
+    INSERT INTO octagon_reports
+      (report_id, ticker, event_ticker, model_prob, market_prob, mispricing_signal,
+       drivers_json, catalysts_json, sources_json, resolution_history_json,
+       contract_snapshot_json, raw_response, model_accuracy, variant_used, fetched_at, expires_at)
+    VALUES
+      ($report_id, $ticker, $event_ticker, $model_prob, $market_prob, $mispricing_signal,
+       $drivers_json, $catalysts_json, $sources_json, $resolution_history_json,
+       $contract_snapshot_json, $raw_response, $model_accuracy, $variant_used, $fetched_at, $expires_at)
+    ON CONFLICT(report_id) DO UPDATE SET
+      ticker = EXCLUDED.ticker,
+      event_ticker = EXCLUDED.event_ticker,
+      model_prob = EXCLUDED.model_prob,
+      market_prob = EXCLUDED.market_prob,
+      mispricing_signal = EXCLUDED.mispricing_signal,
+      drivers_json = EXCLUDED.drivers_json,
+      catalysts_json = EXCLUDED.catalysts_json,
+      sources_json = EXCLUDED.sources_json,
+      resolution_history_json = EXCLUDED.resolution_history_json,
+      contract_snapshot_json = EXCLUDED.contract_snapshot_json,
+      raw_response = EXCLUDED.raw_response,
+      model_accuracy = EXCLUDED.model_accuracy,
+      variant_used = EXCLUDED.variant_used,
+      fetched_at = EXCLUDED.fetched_at,
+      expires_at = EXCLUDED.expires_at
+  `).run({
+    $report_id: report.report_id,
+    $ticker: report.ticker,
+    $event_ticker: report.event_ticker,
+    $model_prob: report.model_prob,
+    $market_prob: report.market_prob ?? null,
+    $mispricing_signal: report.mispricing_signal ?? null,
+    $drivers_json: report.drivers_json ?? null,
+    $catalysts_json: report.catalysts_json ?? null,
+    $sources_json: report.sources_json ?? null,
+    $resolution_history_json: report.resolution_history_json ?? null,
+    $contract_snapshot_json: report.contract_snapshot_json ?? null,
+    $raw_response: report.raw_response ?? null,
+    $model_accuracy: report.model_accuracy ?? null,
+    $variant_used: report.variant_used ?? null,
+    $fetched_at: report.fetched_at,
+    $expires_at: report.expires_at,
+  });
+}
+
+export function getReport(db: Database, reportId: string): OctagonReport | null {
+  return db.query('SELECT * FROM octagon_reports WHERE report_id = $id').get({
+    $id: reportId,
+  }) as OctagonReport | null;
+}
+
+export function getLatestReport(db: Database, ticker: string): OctagonReport | null {
+  return db.query(
+    'SELECT * FROM octagon_reports WHERE ticker = $ticker ORDER BY fetched_at DESC LIMIT 1'
+  ).get({ $ticker: ticker }) as OctagonReport | null;
+}
+
+export function updateReportModelProb(db: Database, reportId: string, modelProb: number): void {
+  db.prepare(
+    `UPDATE octagon_reports SET model_prob = $model_prob WHERE report_id = $report_id`,
+  ).run({ $report_id: reportId, $model_prob: modelProb });
+}
+
+/**
+ * Returns the cache TTL (in seconds) based on how far away the market close time is.
+ *
+ * | Time to close | TTL   |
+ * |---------------|-------|
+ * | <24h          | 1h    |
+ * | 1–7d          | 6h    |
+ * | 7–30d         | 24h   |
+ * | 30d+          | 48h   |
+ * | Already closed| 1h    |
+ */
+export function getTtlForCloseTime(secondsUntilClose: number): number {
+  if (secondsUntilClose <= 0) return 3600;           // already closed → 1h
+  if (secondsUntilClose < 86400) return 3600;        // <24h → 1h
+  if (secondsUntilClose < 7 * 86400) return 21600;   // 1–7d → 6h
+  if (secondsUntilClose < 30 * 86400) return 86400;  // 7–30d → 24h
+  return 172800;                                      // 30d+ → 48h
+}
+
+/**
+ * Returns true if no report exists for this ticker, or the latest is older than the TTL.
+ * When closeTimeEpoch is provided, uses tiered TTL based on market close proximity.
+ * Otherwise falls back to 24h.
+ */
+export function isStale(db: Database, ticker: string, nowSeconds?: number, closeTimeEpoch?: number): boolean {
+  const now = nowSeconds ?? Math.floor(Date.now() / 1000);
+  const report = getLatestReport(db, ticker);
+  if (!report) return true;
+  const ttl = closeTimeEpoch != null
+    ? getTtlForCloseTime(closeTimeEpoch - now)
+    : 86400;
+  return report.fetched_at + ttl < now;
+}

package/src/db/positions.ts

@@ -0,0 +1,71 @@
+import type { Database } from 'bun:sqlite';
+import type { EdgeRow } from './edge.js';
+
+export interface Position {
+  position_id: string;
+  ticker: string;
+  event_ticker: string;
+  direction: string;
+  size: number;
+  entry_price: number;
+  entry_edge?: number | null;
+  entry_kelly?: number | null;
+  current_pnl?: number | null;
+  status?: string | null;
+  opened_at?: number | null;
+  closed_at?: number | null;
+}
+
+export interface PositionWithEdge extends Position {
+  latest_edge?: EdgeRow | null;
+}
+
+export function openPosition(db: Database, position: Position): void {
+  db.prepare(`
+    INSERT INTO positions
+      (position_id, ticker, event_ticker, direction, size, entry_price,
+       entry_edge, entry_kelly, current_pnl, status, opened_at, closed_at)
+    VALUES
+      ($position_id, $ticker, $event_ticker, $direction, $size, $entry_price,
+       $entry_edge, $entry_kelly, $current_pnl, $status, $opened_at, $closed_at)
+  `).run({
+    $position_id: position.position_id,
+    $ticker: position.ticker,
+    $event_ticker: position.event_ticker,
+    $direction: position.direction,
+    $size: position.size,
+    $entry_price: position.entry_price,
+    $entry_edge: position.entry_edge ?? null,
+    $entry_kelly: position.entry_kelly ?? null,
+    $current_pnl: position.current_pnl ?? 0,
+    $status: position.status ?? 'open',
+    $opened_at: position.opened_at ?? null,
+    $closed_at: position.closed_at ?? null,
+  });
+}
+
+export function closePosition(db: Database, positionId: string, closedAt: number): void {
+  db.prepare(
+    "UPDATE positions SET status = 'closed', closed_at = $closed_at WHERE position_id = $id"
+  ).run({ $closed_at: closedAt, $id: positionId });
+}
+
+export function getOpenPositions(db: Database): Position[] {
+  return db.query("SELECT * FROM positions WHERE status = 'open'").all() as Position[];
+}
+
+/**
+ * Get a position with its latest edge_history row joined by ticker.
+ */
+export function getPositionWithEdge(db: Database, positionId: string): PositionWithEdge | null {
+  const position = db.query('SELECT * FROM positions WHERE position_id = $id').get({
+    $id: positionId,
+  }) as Position | null;
+  if (!position) return null;
+
+  const latestEdge = db.query(
+    'SELECT * FROM edge_history WHERE ticker = $ticker ORDER BY timestamp DESC LIMIT 1'
+  ).get({ $ticker: position.ticker }) as EdgeRow | null;
+
+  return { ...position, latest_edge: latestEdge ?? null };
+}

package/src/db/risk.ts

@@ -0,0 +1,51 @@
+import type { Database } from 'bun:sqlite';
+
+export interface RiskSnapshot {
+  id?: number;
+  timestamp: number;
+  cash_balance?: number | null;
+  portfolio_value?: number | null;
+  open_exposure?: number | null;
+  available_bankroll?: number | null;
+  daily_pnl?: number | null;
+  drawdown_current?: number | null;
+  drawdown_max?: number | null;
+  correlation_max?: number | null;
+  positions_count?: number | null;
+  circuit_breaker_on?: number | null;
+}
+
+export function insertRiskSnapshot(db: Database, snapshot: RiskSnapshot): void {
+  db.prepare(`
+    INSERT INTO risk_snapshots
+      (timestamp, cash_balance, portfolio_value, open_exposure, available_bankroll,
+       daily_pnl, drawdown_current, drawdown_max, correlation_max, positions_count, circuit_breaker_on)
+    VALUES
+      ($timestamp, $cash_balance, $portfolio_value, $open_exposure, $available_bankroll,
+       $daily_pnl, $drawdown_current, $drawdown_max, $correlation_max, $positions_count, $circuit_breaker_on)
+  `).run({
+    $timestamp: snapshot.timestamp,
+    $cash_balance: snapshot.cash_balance ?? null,
+    $portfolio_value: snapshot.portfolio_value ?? null,
+    $open_exposure: snapshot.open_exposure ?? null,
+    $available_bankroll: snapshot.available_bankroll ?? null,
+    $daily_pnl: snapshot.daily_pnl ?? null,
+    $drawdown_current: snapshot.drawdown_current ?? null,
+    $drawdown_max: snapshot.drawdown_max ?? null,
+    $correlation_max: snapshot.correlation_max ?? null,
+    $positions_count: snapshot.positions_count ?? null,
+    $circuit_breaker_on: snapshot.circuit_breaker_on ?? 0,
+  });
+}
+
+export function getLatestSnapshot(db: Database): RiskSnapshot | null {
+  return db.query(
+    'SELECT * FROM risk_snapshots ORDER BY timestamp DESC LIMIT 1'
+  ).get() as RiskSnapshot | null;
+}
+
+export function getDrawdownHistory(db: Database, since: number): RiskSnapshot[] {
+  return db.query(
+    'SELECT * FROM risk_snapshots WHERE timestamp >= $since ORDER BY timestamp ASC'
+  ).all({ $since: since }) as RiskSnapshot[];
+}