Certainty Gap Desk — Final Merged Specification

Version: 1.0 — Merged Final Date: 2026-03-15 Panel: Claude Opus 4.6 (base), Gemini 3.1 Pro, Grok 4.1, DeepSeek V3.1, Sonar Reasoning Pro Status: Authoritative build document for coding bot

This document merges all four panel responses into one complete spec. Opus 4.6 is the complete base — nothing removed. Unique contributions from Gemini, Grok, and DeepSeek are tagged [PANEL: Model Name]. This is a data collection spec targeting Kalshi and Polymarket (both ladder-structured prediction markets), plus traditional financial markets. The Certainty Gap IS the edge: where AI/models are highly certain but prediction market prices still imply doubt, you trade the gap.

Table of Contents

1. What Is the Certainty Gap Desk
2. Architecture Decision
3. System Architecture
4. Data Collection Spec
5. SQLite Schema — CREATE Statements
6. API Endpoints and Collection Cadence
7. Storage Estimates
8. All Strategies — Complete Catalog
9. Prediction Market Execution — Kalshi and Polymarket
10. Portfolio Allocation
11. Build Priority
12. Key SQL Queries
13. Implementation Checklist

What Is the Certainty Gap Desk

A cross-market desk that looks for ONE pattern everywhere:

Something is near-100% certain (because of physics, math, or rules), but the market is still pricing it like there's doubt. That gap between certainty and market price is where money lives.

This came out of reviewing the weather lock-in strategy. Temperature always drops after the daily high — that is physics. But Kalshi still prices "over" contracts like the temp might come back up. The same pattern appears in options, crypto, sports, bonds, forex, and prediction markets.

The desk is specifically optimized to find situations where:

• An AI model (or physics model, or rules database) assigns >99% probability to an outcome
• A prediction market (Kalshi, Polymarket) or financial market prices that same outcome at <95%
• The gap (certainty_score - market_implied_probability) exceeds the minimum threshold to be worth trading after fees

The gap IS the edge. We are not forecasting. We are exploiting certainty the market has not priced in.

Architecture Decision

3 out of 4 panel members: STANDALONE desk.

Breakdown:

• Opus: Standalone, unambiguously. Different data, different risk profile, different holding period, different failure modes.
• Grok: Standalone — unique skill set, cross-market nature, future growth as an edge-discovery hub.
• DeepSeek: Start under arbitrage, spin out later as it scales. Compromise position.
• Gemini: [PANEL: Gemini 3.1 Pro] Do not call it a desk at all. Build it as a "Convergence Engine" or "Strategy Engine" that feeds the asset desks. The engine finds the gaps; execution routes to the relevant desk (crypto desk, options desk, etc.). This avoids duplicating API connections and execution logic.

Why this is NOT arbitrage:

[PANEL: Gemini 3.1 Pro] Matrix Architecture framing: Think of the system as a grid. Columns are execution environments (Crypto Desk, Options Desk, Sports Desk). They handle API connections, liquidity checks, and order routing. Rows are Strategy Engines (Arbitrage Engine, Momentum Engine, Convergence/Certainty Engine). The Certainty Gap engine scans for gaps and sends trade instructions to the relevant execution desk. This avoids duplicating infrastructure.

System Architecture

Certainty Gap Desk
├── Pattern Library (the "certainty database" — the moat)
│   ├── Physics-based certainties (weather, thermodynamics)
│   ├── Mathematical certainties (options expiry, theta decay, futures convergence)
│   ├── Rule/structural certainties (sports rules, contracts, redemptions, index rules)
│   └── Statistical near-certainties (>99.5% historical base rate)
│
├── Scanner Layer (per-market monitors)
│   ├── Options scanner (theta, pin risk, expiry mechanics, IV percentile)
│   ├── Crypto scanner (pegs, funding rates, liquidation cascades, futures basis)
│   ├── Volatility scanner (VIX term structure, backwardation detection)
│   ├── Prediction market scanner (Kalshi, Polymarket — ladder structure aware)
│   ├── Sports scanner (live game states, garbage time detection)
│   ├── Weather scanner (NWS physical models vs market prices)
│   ├── Forex/rates scanner (central bank rate differentials, forward curves)
│   ├── Equity scanner (index rebalancing announcements, earnings IV)   [PANEL: Gemini 3.1 Pro]
│   └── Fixed income scanner (callable bond call dates, CEF NAV discounts, tender offers)   [PANEL: Gemini 3.1 Pro]
│
├── Gap Detector (compares certainty level vs market price)
│   ├── Certainty score: how sure are we? (99.5%? 99.99%?)
│   ├── Market implied probability: what does the price say?
│   ├── Gap size: certainty_score - market_implied_prob
│   ├── Threshold filter: only act when gap > minimum edge
│   └── Fee-adjusted net edge: gap minus round-trip trading cost
│
├── Risk Manager
│   ├── Per-trade max exposure
│   ├── Correlation monitor (are multiple bets on same underlying risk?)
│   ├── Tail risk budget (what if the 0.02% event hits?)
│   ├── Kelly criterion position sizing adjusted for certainty level
│   └── Per-strategy capital caps
│
└── Execution Layer
    ├── Kalshi adapter (ladder-structure aware, REST API)
    ├── Polymarket adapter (ladder-structure aware, REST/CLOB API)
    ├── Crypto exchange adapters (Binance, Bybit, Coinbase, DEX)
    ├── Options/equities adapter (IBKR API)
    └── Holding period manager (time-based exits)

The Pattern Library is the moat. Every new certainty gap discovered gets added. The desk becomes a living encyclopedia of market mispricing about known outcomes. Over time, the library compounds in value.

[PANEL: Gemini 3.1 Pro] Execution routing model: The scanner layer does not execute directly. It emits a gap_signal record with: market, instrument, certainty_score, market_implied_prob, gap_size, suggested_action, target_desk. The target desk executes via its own adapters. This keeps execution logic centralized per asset class.

Data Collection Spec

What Gets Collected

For every market we monitor, we collect:

1. Raw market prices — what the market currently implies as probability or price
2. Certainty scores — our computed probability from physics/math/rules/statistics
3. Gap signals — when certainty > market_price by threshold
4. Positions and outcomes — what we traded, at what price, what it settled at
5. Pattern performance — which pattern types produce real edges vs. false positives

Collection feeds by market:

SQLite Schema

All tables go into a single database: /home/ubuntu/edgeclaw/data/db/certainty-gap.db

-- ============================================================
-- CERTAINTY GAP DESK — SQLite Schema
-- /home/ubuntu/edgeclaw/data/db/certainty-gap.db
-- ============================================================

PRAGMA journal_mode=WAL;
PRAGMA foreign_keys=ON;

-- ============================================================
-- PATTERN LIBRARY
-- The growing database of "certainty types" the desk knows about.
-- Each row is a class of certainty gap, not an individual trade.
-- ============================================================

CREATE TABLE IF NOT EXISTS pattern_library (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    pattern_name        TEXT NOT NULL UNIQUE,          -- e.g. "weather_daily_high_lockin"
    category            TEXT NOT NULL,                 -- physics | math | rule | statistical
    description         TEXT NOT NULL,
    source_of_certainty TEXT NOT NULL,                 -- NWS thermodynamics, options math, etc.
    markets             TEXT NOT NULL,                 -- JSON array: ["kalshi","polymarket","options"]
    typical_certainty   REAL NOT NULL,                 -- 0.0-1.0, e.g. 0.9970
    typical_gap_size    REAL,                          -- avg gap seen historically
    win_rate_observed   REAL,                          -- updated from outcomes table
    trade_count         INTEGER DEFAULT 0,
    is_active           INTEGER DEFAULT 1,             -- 0 = retired
    notes               TEXT,
    created_at          TEXT DEFAULT (datetime('now')),
    updated_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_pattern_library_category ON pattern_library(category);
CREATE INDEX IF NOT EXISTS idx_pattern_library_active ON pattern_library(is_active);

-- ============================================================
-- MARKET PRICE SNAPSHOTS
-- Raw price data from all monitored markets.
-- This is the "what does the market say" side of the gap.
-- ============================================================

CREATE TABLE IF NOT EXISTS market_snapshots (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    market_type         TEXT NOT NULL,                 -- kalshi | polymarket | options | vix | crypto_funding | stablecoin | lst | cef | forex | sports_live | earnings_iv
    market_source       TEXT NOT NULL,                 -- exchange or API name
    instrument_id       TEXT NOT NULL,                 -- ticker, contract ID, market slug
    instrument_label    TEXT,                          -- human-readable description
    snapshot_time       TEXT NOT NULL,                 -- ISO8601
    -- prediction market fields
    yes_price           REAL,                          -- 0-1 implied probability (or 0-100 cents)
    no_price            REAL,
    volume_usd          REAL,
    open_interest       REAL,
    close_time          TEXT,                          -- when market resolves
    -- options fields
    option_type         TEXT,                          -- call | put
    strike              REAL,
    expiry              TEXT,
    iv                  REAL,
    delta               REAL,
    theta               REAL,
    gamma               REAL,
    bid                 REAL,
    ask                 REAL,
    -- VIX fields
    vix_spot            REAL,
    vix_m1_futures      REAL,
    vix_m2_futures      REAL,
    term_structure_slope REAL,                         -- m1-m2, negative = backwardation
    -- crypto fields
    funding_rate        REAL,                          -- 8h rate, e.g. 0.0001 = 0.01%
    funding_rate_annualized REAL,
    spot_price          REAL,
    futures_price       REAL,
    basis_pct           REAL,                          -- (futures-spot)/spot
    liquidations_1h_usd REAL,
    liquidations_4h_usd REAL,
    -- stablecoin / LST fields
    peg_target          REAL DEFAULT 1.0,
    peg_deviation       REAL,                          -- current_price - peg_target
    redemption_queue_days INTEGER,
    -- CEF / bond fields
    nav                 REAL,
    market_price        REAL,
    discount_pct        REAL,                          -- (market_price - nav) / nav
    call_date           TEXT,
    call_price          REAL,
    -- forex fields
    spot_rate           REAL,
    forward_1m          REAL,
    forward_3m          REAL,
    base_interest_rate  REAL,
    quote_interest_rate REAL,
    rate_differential   REAL,
    -- sports fields
    score_diff          REAL,                          -- home minus away
    time_remaining_sec  INTEGER,
    win_prob_live       REAL,                          -- sportsbook implied
    -- earnings fields
    historical_move_avg REAL,                          -- avg actual move over N earnings
    implied_move        REAL,                          -- what options are pricing
    move_overpricing    REAL,                          -- implied - historical
    raw_payload         TEXT,                          -- full JSON from API for reprocessing
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_snapshots_market_type ON market_snapshots(market_type);
CREATE INDEX IF NOT EXISTS idx_snapshots_instrument ON market_snapshots(instrument_id);
CREATE INDEX IF NOT EXISTS idx_snapshots_time ON market_snapshots(snapshot_time);
CREATE INDEX IF NOT EXISTS idx_snapshots_type_time ON market_snapshots(market_type, snapshot_time);

-- ============================================================
-- CERTAINTY SCORES
-- Our computed probability from physics/math/rules/statistics.
-- This is the "what do WE know" side of the gap.
-- ============================================================

CREATE TABLE IF NOT EXISTS certainty_scores (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    pattern_id          INTEGER REFERENCES pattern_library(id),
    instrument_id       TEXT NOT NULL,                 -- same key as market_snapshots
    computed_at         TEXT NOT NULL,
    certainty_score     REAL NOT NULL,                 -- 0.0-1.0, our confidence in outcome
    outcome_direction   TEXT NOT NULL,                 -- YES | NO | UP | DOWN | REPEG | DECAY
    certainty_source    TEXT NOT NULL,                 -- NWS_API | options_math | kelly | historical_base_rate
    model_inputs        TEXT,                          -- JSON of the inputs used to compute
    supporting_evidence TEXT,                          -- JSON array of evidence items
    expiry              TEXT,                          -- when this certainty expires (trade window closes)
    is_stale            INTEGER DEFAULT 0,             -- 1 if certainty_score was revised
    notes               TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_certainty_pattern ON certainty_scores(pattern_id);
CREATE INDEX IF NOT EXISTS idx_certainty_instrument ON certainty_scores(instrument_id);
CREATE INDEX IF NOT EXISTS idx_certainty_time ON certainty_scores(computed_at);

-- ============================================================
-- GAP SIGNALS
-- When certainty_score - market_implied_prob exceeds threshold.
-- These are the actionable alerts.
-- ============================================================

CREATE TABLE IF NOT EXISTS gap_signals (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    pattern_id          INTEGER REFERENCES pattern_library(id),
    certainty_score_id  INTEGER REFERENCES certainty_scores(id),
    snapshot_id         INTEGER REFERENCES market_snapshots(id),
    instrument_id       TEXT NOT NULL,
    instrument_label    TEXT,
    market_type         TEXT NOT NULL,
    detected_at         TEXT NOT NULL,
    -- gap math
    certainty_score     REAL NOT NULL,
    market_implied_prob REAL NOT NULL,
    gap_size            REAL NOT NULL,                 -- certainty_score - market_implied_prob
    fee_estimate        REAL DEFAULT 0.0,              -- round-trip cost as fraction
    net_edge            REAL,                          -- gap_size - fee_estimate
    -- signal metadata
    recommended_action  TEXT,                          -- BUY_YES | BUY_NO | SELL_PUT | SHORT_VIX | etc.
    position_size_kelly REAL,                          -- Kelly fraction of bankroll
    max_capital_usd     REAL,                          -- hard cap regardless of Kelly
    holding_period_est  TEXT,                          -- e.g. "2-6 hours" "1-3 days"
    target_desk         TEXT,                          -- which desk should execute
    -- outcome
    signal_status       TEXT DEFAULT 'open',           -- open | traded | expired | dismissed
    dismissed_reason    TEXT,
    trade_id            INTEGER,                       -- FK to trades table, set on execution
    resolved_at         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_signals_status ON gap_signals(signal_status);
CREATE INDEX IF NOT EXISTS idx_signals_detected ON gap_signals(detected_at);
CREATE INDEX IF NOT EXISTS idx_signals_market ON gap_signals(market_type);
CREATE INDEX IF NOT EXISTS idx_signals_net_edge ON gap_signals(net_edge DESC);
CREATE INDEX IF NOT EXISTS idx_signals_instrument ON gap_signals(instrument_id);

-- ============================================================
-- TRADES
-- Every position taken by the desk.
-- ============================================================

CREATE TABLE IF NOT EXISTS trades (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    signal_id           INTEGER REFERENCES gap_signals(id),
    pattern_id          INTEGER REFERENCES pattern_library(id),
    instrument_id       TEXT NOT NULL,
    instrument_label    TEXT,
    market_type         TEXT NOT NULL,
    direction           TEXT NOT NULL,                 -- YES | NO | LONG | SHORT | SELL_CALL | etc.
    entry_time          TEXT NOT NULL,
    entry_price         REAL NOT NULL,                 -- in probability (0-1) or dollar price
    position_size_usd   REAL NOT NULL,
    max_loss_usd        REAL,
    -- exit
    exit_time           TEXT,
    exit_price          REAL,
    exit_reason         TEXT,                          -- expiry | target_hit | stop_loss | manual
    -- P&L
    gross_pnl_usd       REAL,
    fees_paid_usd       REAL DEFAULT 0.0,
    net_pnl_usd         REAL,
    return_pct          REAL,                          -- net_pnl / position_size_usd
    -- context at entry
    certainty_at_entry  REAL,
    market_price_at_entry REAL,
    gap_at_entry        REAL,
    -- context at exit
    outcome             TEXT,                          -- win | loss | partial | pushed
    notes               TEXT,
    created_at          TEXT DEFAULT (datetime('now')),
    updated_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_trades_signal ON trades(signal_id);
CREATE INDEX IF NOT EXISTS idx_trades_market ON trades(market_type);
CREATE INDEX IF NOT EXISTS idx_trades_time ON trades(entry_time);
CREATE INDEX IF NOT EXISTS idx_trades_outcome ON trades(outcome);
CREATE INDEX IF NOT EXISTS idx_trades_pattern ON trades(pattern_id);

-- ============================================================
-- PATTERN PERFORMANCE SUMMARY
-- Materialized view (maintained by code) of per-pattern stats.
-- Updated after each trade settlement.
-- ============================================================

CREATE TABLE IF NOT EXISTS pattern_performance (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    pattern_id          INTEGER REFERENCES pattern_library(id) UNIQUE,
    total_trades        INTEGER DEFAULT 0,
    wins                INTEGER DEFAULT 0,
    losses              INTEGER DEFAULT 0,
    pushes              INTEGER DEFAULT 0,
    win_rate            REAL,
    total_gross_pnl     REAL DEFAULT 0.0,
    total_fees          REAL DEFAULT 0.0,
    total_net_pnl       REAL DEFAULT 0.0,
    avg_return_pct      REAL,
    avg_certainty_at_entry REAL,
    avg_gap_at_entry    REAL,
    avg_holding_hours   REAL,
    sharpe_ratio        REAL,
    max_single_loss_usd REAL,
    max_drawdown_usd    REAL,
    last_trade_at       TEXT,
    updated_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_perf_pattern ON pattern_performance(pattern_id);

-- ============================================================
-- KALSHI MARKET INDEX
-- Tracks known Kalshi markets relevant to certainty gap strategies.
-- Refreshed daily.
-- ============================================================

CREATE TABLE IF NOT EXISTS kalshi_markets (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    ticker              TEXT NOT NULL UNIQUE,
    title               TEXT,
    category            TEXT,                          -- weather | economic | sports | politics | etc.
    yes_price           REAL,                          -- latest cents (0-100)
    no_price            REAL,
    volume_24h          REAL,
    open_interest       REAL,
    close_time          TEXT,
    result              TEXT,                          -- null until settled
    pattern_match       TEXT,                          -- which pattern_library entry this maps to
    is_active           INTEGER DEFAULT 1,
    last_checked        TEXT,
    created_at          TEXT DEFAULT (datetime('now')),
    updated_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_kalshi_category ON kalshi_markets(category);
CREATE INDEX IF NOT EXISTS idx_kalshi_close ON kalshi_markets(close_time);
CREATE INDEX IF NOT EXISTS idx_kalshi_active ON kalshi_markets(is_active);
CREATE INDEX IF NOT EXISTS idx_kalshi_pattern ON kalshi_markets(pattern_match);

-- ============================================================
-- POLYMARKET MARKET INDEX
-- Tracks known Polymarket markets relevant to certainty gap strategies.
-- ============================================================

CREATE TABLE IF NOT EXISTS polymarket_markets (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    condition_id        TEXT NOT NULL UNIQUE,
    slug                TEXT,
    title               TEXT,
    category            TEXT,
    yes_price           REAL,                          -- 0.0-1.0 USDC
    no_price            REAL,
    volume_24h          REAL,
    liquidity_usd       REAL,
    end_date            TEXT,
    resolved            INTEGER DEFAULT 0,
    resolution          TEXT,                          -- YES | NO | null
    pattern_match       TEXT,
    is_active           INTEGER DEFAULT 1,
    last_checked        TEXT,
    created_at          TEXT DEFAULT (datetime('now')),
    updated_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_poly_category ON polymarket_markets(category);
CREATE INDEX IF NOT EXISTS idx_poly_end ON polymarket_markets(end_date);
CREATE INDEX IF NOT EXISTS idx_poly_active ON polymarket_markets(is_active);
CREATE INDEX IF NOT EXISTS idx_poly_pattern ON polymarket_markets(pattern_match);

-- ============================================================
-- WEATHER OBSERVATIONS
-- NWS data for weather-based certainty strategies.
-- ============================================================

CREATE TABLE IF NOT EXISTS weather_observations (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    station_id          TEXT NOT NULL,
    city                TEXT,
    observation_time    TEXT NOT NULL,
    temperature_f       REAL,
    temperature_c       REAL,
    daily_high_f        REAL,                          -- max so far today
    daily_low_f         REAL,                          -- min so far today
    forecast_high_f     REAL,                          -- NWS forecast for today
    forecast_low_f      REAL,
    sunrise_time        TEXT,
    sunset_time         TEXT,
    is_post_sunrise     INTEGER,                       -- 1 if past sunrise
    is_post_peak        INTEGER,                       -- 1 if temp has started falling
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_weather_station ON weather_observations(station_id);
CREATE INDEX IF NOT EXISTS idx_weather_time ON weather_observations(observation_time);
CREATE INDEX IF NOT EXISTS idx_weather_station_time ON weather_observations(station_id, observation_time);

-- ============================================================
-- VIX TIMESERIES
-- Dedicated table for VIX data (high write frequency).
-- ============================================================

CREATE TABLE IF NOT EXISTS vix_timeseries (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    observed_at         TEXT NOT NULL,
    vix_spot            REAL,
    vix_m1              REAL,
    vix_m2              REAL,
    vix_m3              REAL,
    contango_m1_m2      REAL,                          -- m1-m2 spread (positive = contango, negative = backwardation)
    realized_vol_30d    REAL,
    vol_risk_premium    REAL,                          -- vix_spot - realized_vol_30d
    spike_flag          INTEGER DEFAULT 0,             -- 1 if vix_spot > 30
    reversion_signal    INTEGER DEFAULT 0,             -- 1 if spike is fading (first down day)
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_vix_time ON vix_timeseries(observed_at);
CREATE INDEX IF NOT EXISTS idx_vix_spike ON vix_timeseries(spike_flag, observed_at);

-- ============================================================
-- CRYPTO FUNDING RATES
-- Dedicated table for funding rate data across exchanges.
-- ============================================================

CREATE TABLE IF NOT EXISTS crypto_funding_rates (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    exchange            TEXT NOT NULL,                 -- binance | bybit | dydx | hyperliquid
    symbol              TEXT NOT NULL,                 -- BTCUSDT, ETHUSDT, etc.
    funding_time        TEXT NOT NULL,
    funding_rate        REAL NOT NULL,                 -- 8h rate
    funding_rate_annualized REAL,                      -- funding_rate * 3 * 365
    mark_price          REAL,
    spot_price          REAL,
    basis              REAL,                           -- mark - spot
    open_interest_usd   REAL,
    is_favorable        INTEGER DEFAULT 0,             -- 1 if rate > threshold (worthwhile to harvest)
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE UNIQUE INDEX IF NOT EXISTS idx_funding_unique ON crypto_funding_rates(exchange, symbol, funding_time);
CREATE INDEX IF NOT EXISTS idx_funding_symbol ON crypto_funding_rates(symbol);
CREATE INDEX IF NOT EXISTS idx_funding_favorable ON crypto_funding_rates(is_favorable, funding_time);

-- ============================================================
-- CRYPTO LIQUIDATIONS
-- Liquidation cascade data for cascade recovery strategy.
-- ============================================================

CREATE TABLE IF NOT EXISTS crypto_liquidations (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    observed_at         TEXT NOT NULL,
    symbol              TEXT NOT NULL,
    exchange            TEXT,
    liq_usd_1h          REAL,                          -- rolling 1h liquidation total
    liq_usd_4h          REAL,                          -- rolling 4h liquidation total
    liq_usd_24h         REAL,
    long_liq_usd_1h     REAL,
    short_liq_usd_1h    REAL,
    spot_price          REAL,
    cascade_signal      INTEGER DEFAULT 0,             -- 1 if >$500M in 1-4h for BTC
    funding_rate        REAL,                          -- negative = shorts paying longs (max bearish)
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_liq_symbol ON crypto_liquidations(symbol);
CREATE INDEX IF NOT EXISTS idx_liq_time ON crypto_liquidations(observed_at);
CREATE INDEX IF NOT EXISTS idx_liq_cascade ON crypto_liquidations(cascade_signal, observed_at);

-- ============================================================
-- STABLECOIN PRICES
-- Price monitoring for depeg detection.
-- ============================================================

CREATE TABLE IF NOT EXISTS stablecoin_prices (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    observed_at         TEXT NOT NULL,
    symbol              TEXT NOT NULL,                 -- USDC, USDT, DAI
    exchange            TEXT NOT NULL,
    price_usd           REAL NOT NULL,
    volume_24h          REAL,
    peg_deviation       REAL,                          -- price - 1.0
    depeg_alert_level   TEXT,                          -- none | alert | buy_tranche_1 | buy_tranche_2 | buy_tranche_3
    -- tranche thresholds: alert=$0.995, t1=$0.98, t2=$0.97, t3=$0.96
    is_algorithmic      INTEGER DEFAULT 0,             -- 0 = collateralized, 1 = never trade
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_stable_symbol ON stablecoin_prices(symbol);
CREATE INDEX IF NOT EXISTS idx_stable_time ON stablecoin_prices(observed_at);
CREATE INDEX IF NOT EXISTS idx_stable_alert ON stablecoin_prices(depeg_alert_level, observed_at);

-- ============================================================
-- CEF (CLOSED-END FUND) TRACKING
-- NAV discount monitoring and tender offer tracking.
-- [PANEL: Gemini 3.1 Pro]
-- ============================================================

CREATE TABLE IF NOT EXISTS cef_snapshots (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    ticker              TEXT NOT NULL,
    fund_name           TEXT,
    category            TEXT,                          -- muni | equity | bond | etc.
    nav                 REAL NOT NULL,
    market_price        REAL NOT NULL,
    discount_pct        REAL NOT NULL,                 -- (market-nav)/nav, negative = discount
    historical_avg_discount REAL,
    discount_z_score    REAL,                          -- how unusual is this discount
    has_tender_offer    INTEGER DEFAULT 0,
    tender_offer_price  REAL,                          -- % of NAV if tender exists
    tender_expiry       TEXT,
    observed_at         TEXT NOT NULL,
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_cef_ticker ON cef_snapshots(ticker);
CREATE INDEX IF NOT EXISTS idx_cef_discount ON cef_snapshots(discount_pct);
CREATE INDEX IF NOT EXISTS idx_cef_tender ON cef_snapshots(has_tender_offer);

-- ============================================================
-- INDEX REBALANCING EVENTS
-- Tracks S&P 500 and Russell additions/deletions.
-- [PANEL: Gemini 3.1 Pro]
-- ============================================================

CREATE TABLE IF NOT EXISTS index_rebalancing (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    ticker              TEXT NOT NULL,
    company_name        TEXT,
    index_name          TEXT NOT NULL,                 -- SP500 | Russell2000 | Russell1000 | etc.
    action              TEXT NOT NULL,                 -- ADD | REMOVE
    announcement_date   TEXT NOT NULL,
    effective_date      TEXT NOT NULL,
    sector              TEXT,
    sector_etf_hedge    TEXT,                          -- which ETF to short as hedge
    -- opportunity window
    entry_signal_date   TEXT,                          -- when to buy (after announcement)
    exit_signal_date    TEXT,                          -- when to sell (effective_date close)
    estimated_forced_buying_usd REAL,                 -- approx. how much index funds must buy
    -- outcome tracking
    price_at_announcement REAL,
    price_at_effective   REAL,
    pct_return          REAL,
    trade_id            INTEGER REFERENCES trades(id),
    notes               TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_rebal_ticker ON index_rebalancing(ticker);
CREATE INDEX IF NOT EXISTS idx_rebal_effective ON index_rebalancing(effective_date);
CREATE INDEX IF NOT EXISTS idx_rebal_index ON index_rebalancing(index_name);

-- ============================================================
-- EARNINGS IV TRACKING
-- Historical move vs implied move for earnings IV crush.
-- ============================================================

CREATE TABLE IF NOT EXISTS earnings_iv_history (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    ticker              TEXT NOT NULL,
    earnings_date       TEXT NOT NULL,
    -- pre-earnings state
    implied_move_pct    REAL,                          -- what options implied before earnings
    iv_rank             REAL,                          -- IV rank 0-100
    straddle_price      REAL,
    -- post-earnings actual
    actual_move_pct     REAL,                          -- what actually happened
    direction           TEXT,                          -- UP | DOWN
    iv_crush_pct        REAL,                          -- how much IV dropped after
    -- analysis
    move_overpriced     REAL,                          -- implied - actual (positive = options were expensive)
    edge_available      INTEGER DEFAULT 0,             -- 1 if historical pattern suggests selling is profitable
    -- trade outcome if we traded
    trade_id            INTEGER REFERENCES trades(id),
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE UNIQUE INDEX IF NOT EXISTS idx_earnings_unique ON earnings_iv_history(ticker, earnings_date);
CREATE INDEX IF NOT EXISTS idx_earnings_ticker ON earnings_iv_history(ticker);
CREATE INDEX IF NOT EXISTS idx_earnings_edge ON earnings_iv_history(edge_available);

-- ============================================================
-- LST (LIQUID STAKING TOKEN) PRICES
-- stETH, cbETH, rETH tracking for redemption arbitrage.
-- [PANEL: Gemini 3.1 Pro]
-- ============================================================

CREATE TABLE IF NOT EXISTS lst_prices (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    token               TEXT NOT NULL,                 -- stETH | cbETH | rETH
    underlying          TEXT NOT NULL,                 -- ETH
    exchange_or_pool    TEXT NOT NULL,                 -- curve | coinbase | uniswap
    price_in_underlying REAL NOT NULL,                 -- e.g. 0.9700 for 1 stETH = 0.97 ETH
    discount_pct        REAL NOT NULL,                 -- 1 - price_in_underlying
    redemption_queue_days INTEGER,
    smart_contract      TEXT,                          -- for direct redemption calls
    redemption_possible INTEGER DEFAULT 1,             -- 0 if contract paused
    observed_at         TEXT NOT NULL,
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_lst_token ON lst_prices(token);
CREATE INDEX IF NOT EXISTS idx_lst_discount ON lst_prices(discount_pct DESC);
CREATE INDEX IF NOT EXISTS idx_lst_time ON lst_prices(observed_at);

-- ============================================================
-- SPORTS LIVE GAME STATES
-- For garbage time detection and live sports certainty gaps.
-- ============================================================

CREATE TABLE IF NOT EXISTS sports_live_states (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    game_id             TEXT NOT NULL,
    sport               TEXT NOT NULL,                 -- NBA | NFL | NHL | MLB | NCAAB
    observed_at         TEXT NOT NULL,
    home_team           TEXT,
    away_team           TEXT,
    home_score          REAL,
    away_score          REAL,
    score_diff          REAL,                          -- home - away
    time_remaining_sec  INTEGER,
    quarter_period      INTEGER,
    -- derived
    win_prob_true       REAL,                          -- our computed true win probability
    win_prob_live_market REAL,                         -- what sportsbooks say
    garbage_time_flag   INTEGER DEFAULT 0,             -- 1 if score_diff and time trigger near-certain win
    kalshi_market_id    TEXT,
    polymarket_id       TEXT,
    raw_payload         TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_sports_game ON sports_live_states(game_id);
CREATE INDEX IF NOT EXISTS idx_sports_time ON sports_live_states(observed_at);
CREATE INDEX IF NOT EXISTS idx_sports_garbage ON sports_live_states(garbage_time_flag, sport);

-- ============================================================
-- COLLECTION LOG
-- Tracks every data collection run for debugging and monitoring.
-- ============================================================

CREATE TABLE IF NOT EXISTS collection_log (
    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
    collector_name      TEXT NOT NULL,                 -- which collector ran
    run_at              TEXT NOT NULL,
    records_written     INTEGER DEFAULT 0,
    duration_ms         INTEGER,
    success             INTEGER DEFAULT 1,             -- 0 = error
    error_message       TEXT,
    created_at          TEXT DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_log_collector ON collection_log(collector_name);
CREATE INDEX IF NOT EXISTS idx_log_time ON collection_log(run_at);
CREATE INDEX IF NOT EXISTS idx_log_success ON collection_log(success);

API Endpoints and Collection Cadence

Kalshi

Base URL: https://api.elections.kalshi.com/trade-api/v2
Auth: RSA-PSS signing (API Key ID: 54bc18ae-be42-49a7-a498-d336818c0d3b)

GET /markets
  - Params: limit=200, status=open, category={weather|economic|sports|...}
  - Cadence: Every 5 minutes for active markets, every 60 minutes for sweep of all categories
  - Fields to store: ticker, title, yes_ask, no_ask, volume, close_time, category

GET /markets/{ticker}/orderbook
  - Cadence: Every 60 seconds for markets flagged as gap_candidate
  - Fields: best_yes, best_no, depth

GET /markets/{ticker}
  - Cadence: On resolution (settled markets)
  - Fields: result, settled_price

Polymarket

Base URL: https://gamma-api.polymarket.com
No auth for market data reads.

GET /markets?active=true&closed=false&limit=100
  - Cadence: Every 5 minutes
  - Fields: condition_id, question, outcomes, outcomePrices, volume24hr, endDate

CLOB API: https://clob.polymarket.com
GET /markets/{condition_id}
  - Cadence: Every 60 seconds for gap candidates
  - Fields: yes, no prices from order book

Websocket: wss://clob.polymarket.com/ws/market
  - Subscribe to specific condition_ids for near-real-time prices
  - Use for any active trade positions

NWS Weather

Base URL: https://api.weather.gov
No auth required.

GET /stations/{station_id}/observations/latest
  - Stations: NWS station IDs for cities with active Kalshi weather markets
  - Cadence: Every 15 minutes
  - Fields: temperature, timestamp

GET /gridpoints/{office}/{gridX},{gridY}/forecast/hourly
  - Cadence: Every 60 minutes
  - Fields: temperature (hourly forecast), startTime

GET /points/{lat},{lon}
  - One-time call per city to get gridpoint coordinates

Sunrise/sunset: api.sunrise-sunset.org/json?lat={}&lng={}&date=today
  - Cadence: Once daily at midnight

CBOE / VIX Data

VIX spot:
  URL: https://cdn.cboe.com/api/global/delayed_quotes/charts/historical/_VIX.json
  Cadence: Every 5 minutes during market hours (9:30AM-4PM ET weekdays)

VIX futures term structure:
  URL: https://www.cboe.com/delayed_quotes/vx/term_structure  (scrape)
  OR: IBKR API for real-time VIX futures (requires account)
  Cadence: Every 5 minutes during market hours

Realized vol:
  Compute from SPX daily closes (calculate 30-day trailing HV)
  Source: Yahoo Finance or IBKR historical data

Crypto — Binance

Base URL: https://api.binance.com/api/v3
WebSocket: wss://stream.binance.com:9443/ws

Funding rates:
  REST: GET /fapi/v1/fundingRate?symbol={}&limit=1
  Cadence: Every 5 minutes per symbol (BTC, ETH, SOL, top 20 by OI)
  WebSocket: wss://fstream.binance.com/ws/{symbol}@markPrice  (real-time)

Liquidations:
  WebSocket: wss://fstream.binance.com/ws/!forceOrder@arr  (all symbols)
  Cadence: Real-time stream, aggregate into 1h/4h rolling windows

Futures basis:
  Spot: GET /api/v3/ticker/price?symbol=BTCUSDT
  Futures: GET /fapi/v1/ticker/price?symbol=BTCUSDT  (quarterly)
  Cadence: Every 5 minutes

Coinglass (Liquidation Aggregation)

Base URL: https://open-api.coinglass.com/public/v2
API key available on free tier.

GET /indicator/liquidation_history?symbol=BTC&time_type=h1&limit=24
  Cadence: Every 10 minutes
  Fields: liqUsd, longLiqUsd, shortLiqUsd, time

GET /futures/liquidation/detail/chart?symbol=BTC&interval=1h
  Cadence: Every 15 minutes

Stablecoin Prices

Coinbase: GET https://api.coinbase.com/v2/prices/USDC-USD/spot
Binance: GET https://api.binance.com/api/v3/ticker/price?symbol=USDCUSDT
Kraken: GET https://api.kraken.com/0/public/Ticker?pair=USDCUSD
DEX (Curve): The Graph API or direct RPC call to Curve USDC pool
  Endpoint: https://api.thegraph.com/subgraphs/name/curvefi/curve

Cadence: Every 60 seconds for all stablecoins (USDC, USDT, DAI)
Alert threshold: price < 0.995 = log alert, price < 0.98 = gap_signal

SEC EDGAR (CEF Tender Offers and Index Events)

EDGAR full-text search:
  URL: https://efts.sec.gov/LATEST/search-index?q=%22tender+offer%22&dateRange=custom&startdt={yesterday}&enddt={today}&forms=TO-I
  Cadence: Daily at 6:00 AM ET

S&P Dow Jones press releases:
  URL: https://www.spglobal.com/spdji/en/search/#overview  (scrape)
  Cadence: Daily at 6:00 AM ET and 6:00 PM ET (announcements after close)

FTSE Russell:
  URL: https://www.ftserussell.com/resources/russel-reconstitution  (scrape)
  Cadence: Daily during reconstitution season (May-June for Russell)

The Odds API (Sports)

API key: f63a46439d104a3a78dee17580c96279
Base URL: https://api.the-odds-api.com/v4

GET /sports/{sport}/odds?apiKey={}&markets=h2h&regions=us&live=true
  Sports: basketball_nba | americanfootball_nfl | icehockey_nhl | baseball_mlb
  Cadence: Every 30 seconds during live games
  Fields: home_team, away_team, bookmakers[0].markets[0].outcomes (live h2h)

ESPN live scores (supplemental for game state):
  URL: https://site.api.espn.com/apis/site/v2/sports/{sport}/scoreboard
  Cadence: Every 30 seconds during games
  Fields: score, clock, quarter/period, status

OANDA (Forex)

Base URL: https://api-fxtrade.oanda.com/v3
Auth: Bearer {OANDA_API_KEY} (existing key in forex bot)

GET /instruments/{pair}/candles?count=1&granularity=M1
  Cadence: Every 60 minutes
  Pairs: USD_JPY, USD_MXN, EUR_USD, GBP_USD (top carry differentials)

Central bank rate data:
  Fed: https://www.federalreserve.gov/releases/h15/  (scrape, daily)
  BOJ: https://www.stat-search.boj.or.jp/ (daily)
  ECB: https://data.ecb.europa.eu/data/datasets/FM (daily)

LST Prices (Liquid Staking Tokens)

CoinGecko:
  GET https://api.coingecko.com/api/v3/simple/price?ids=staked-ether,coinbase-wrapped-staked-eth,rocket-pool-eth&vs_currencies=eth
  Cadence: Every 5 minutes

Curve pool price (on-chain via RPC):
  Pool: 0xDC24316b9AE028F1497c275EB9192a3Ea0f67022  (stETH/ETH pool)
  Read: pool.get_dy(0, 1, 1e18) / 1e18 = price of 1 stETH in ETH
  RPC: Infura or Alchemy endpoint
  Cadence: Every 5 minutes

Storage Estimates

Total estimated monthly storage: ~500 MB

With WAL mode and standard SQLite compression, real disk usage will be roughly 40-60% of that. Recommend a daily vacuum on the DB and archiving market_snapshots older than 90 days to a compressed SQLite file.

Archive strategy:

• Keep hot data (last 30 days) in certainty-gap.db
• Archive old market_snapshots to certainty-gap-archive-YYYY-MM.db
• Never archive trades, pattern_performance, gap_signals, or pattern_library

All Strategies — Complete Catalog

Tier 1: Near-Physics Level Certain

1. Options Theta Decay (0DTE)

• The certainty: Options lose ALL time value by 4PM on expiration day. Mathematical definition of an option, not a forecast.
• Market: SPX/SPY 0DTE options. Also QQQ, IWM, AAPL, TSLA, AMZN.
• The trade: Sell OTM strangles or credit spreads in the final 1-3 hours. Wait for options to go to zero.
• Variant A — Conditional Theta Harvest: Wait for intraday vol spike. Sell OTM credit spreads in opposite direction. Spike inflates premium you collect; theta certainty unchanged.
• Variant B — Pin Exploitation: Identify strikes with massive open interest. Sell straddles around the pin in final 2 hours. Underlying is being mechanically pulled toward pin AND theta is decaying at maximum rate.
• Variant C — IV vs Realized Vol: When 0DTE implied vol > 2x the 30-day realized vol, sell it. IV must converge to realized vol — this is mathematical.
• Win rate: 70-85%
• Return: 20-60% per year
• Capital: $25K-$100K to start
• Scale to: $2M-$5M (SPX 0DTE trades $1B+ notional daily)
• Risk: Flash crash in final hour blows through spreads. ALWAYS use spreads (defined risk), never naked options.
• Automation: Full. IBKR API, real-time options chain data. Python + ib_insync.
• Models: All 4 panels identified this independently.

2. Weather Daily High Lock-In (Existing Strategy)

• The certainty: Temperature ALWAYS drops after the daily peak. Physics (solar angle, thermodynamics).
• How: After peak is confirmed, sell "over" contracts on Kalshi where current temp has passed maximum.
• Win rate: 97-99%
• Already running — needs faster polling (15min), NWS forecast integration, and automatic overnight-low expansion.

3. Weather Overnight Low Lock-In

• The certainty: After sunrise, temperatures ALWAYS rise. Same physics, reversed.
• How: At 6-7AM after overnight low is set and sun is rising, sell "under" contracts on Kalshi.
• Win rate: 97-99%
• Automation: Copy-paste of existing weather bot with sunrise time logic.
• Models: Opus.

4. Stablecoin Depeg Buying

• The certainty: Fully-collateralized stablecoins (USDC, DAI) MUST return to $1 because you can redeem them directly with Circle/MakerDAO for $1. The only failure mode is actual insolvency.
• How: Buy USDC at $0.97-$0.99 during panic. Sell at $1.00 on repeg.
• Buy schedule: 20% at $0.98, 20% at $0.97, 20% at $0.96, 20% at $0.95, 20% at $0.94.
• Enhanced version: During depeg panic, funding rates on perps go deeply negative. Go long stablecoin spot AND long perp. Earn the depeg recovery AND collect funding while waiting.
• Win rate: 95-97% (3-5% = genuine insolvency like UST, but that was algorithmic — never collateralized)
• Return: 2-13% per event in hours to days; blended annual 10-30%
• Capital: $5K+, no real minimum
• Scale to: $10M+ (hundreds of millions traded during SVB depeg — USDC to $0.87, back in 3 days)
• Automation: Full set-and-forget monitoring bot.
• CRITICAL: Only fully-collateralized, audited stablecoins. NEVER algorithmic (UST, FRAX undercollateralized mode).
• Models: All 4 panels.

Tier 2: Structural / Math Certain

5. Crypto Funding Rate Harvest

• The certainty: Perpetual futures funding payments are mechanical transfers, not bets. Longs pay shorts (or vice versa) every 8 hours. Contractual obligation.
• How: Buy 1 BTC spot + short 1 BTC perpetual. Net directional exposure is zero. Collect funding like a paycheck.
• Dynamic allocation: Monitor funding rates across 20+ perpetual markets. Rank by rate. Allocate to top 5-10. Rebalance weekly. Deploy maximum capital during bull market euphoria when rates spike.
• Win rate: ~99% on individual funding collections
• Return: 15-40% per year in normal markets; 50-100%+ during bull market euphoria (0.05-0.1% per 8h = 55-110% annualized)
• Capital: $10K minimum, $50K+ preferred
• Scale to: $20M+ across multiple pairs/exchanges
• Risk: Exchange insolvency (FTX lesson — cap 30% on any single exchange), funding flips negative (close position), liquidation on short leg during pump
• Automation: Full. One of the most mature bot ecosystems in crypto.
• Models: Opus, Gemini, DeepSeek.

6. VIX Mean Reversion

• The certainty: VIX has NEVER stayed above 40 for more than ~30 trading days. Mean reversion is structural — high VIX makes hedging expensive, so institutions sell options to harvest premium, which mechanically pushes VIX down. The market's own structure forces the reversion.
• Entry conditions (ALL must be met):
  1. VIX spot > 30
  2. VIX elevated for at least 3-5 days
  3. VIX futures in backwardation (M1 > M2)
  4. First day where VIX closes lower than it opened after the spike
• Conservative trade: Buy VIX put spreads 2-3 months out (60-90 DTE, NOT weeklies)
• Moderate: Short VIX futures front month, hedged with VIX call at higher strike
• Aggressive (small accounts): Short UVXY or buy UVXY puts. UVXY has structural decay from contango roll — designed to go down over time.
• Win rate: 70-90% (VIX always comes back; question is timing)
• Return: 25-80% per year when deployed; capital sits idle between spikes
• Capital: $25K-$100K
• Frequency: 3-6 tradeable spikes per year
• Scale to: $5M-$10M+ (VIX futures trade ~200K contracts/day)
• Risk: 2008-style crisis where VIX stays elevated for months. Use 60-90 DTE options. Size so total loss < 10% of portfolio.
• Automation: Semi. Entry signal fully automated. Execution benefits from human oversight during chaotic spike periods.
• Models: All 4 panels.

7. Crypto Futures Cash-and-Carry

• The certainty: Futures contracts MUST equal spot price at expiration. Mathematical absolute enforced by convergence.
• How: BTC spot at $60K, Dec futures at $63K. Buy spot, short quarterly futures simultaneously. They converge at expiration. Pocket $3K (5%) regardless of BTC direction.
• Win rate: 99.9% (only risk = exchange bankruptcy/counterparty)
• Return: 8-25% per year (varies with market exuberance)
• Capital: $10K+
• Scale to: $100M+
• Automation: 100%. Very easy to code with ccxt.
• [PANEL: Gemini 3.1 Pro] This is pure "Time/Math" certainty — spot and futures converge by mathematical definition. Identify when futures premium exceeds target threshold before entering.

8. Earnings IV Crush

• The certainty: Implied volatility ALWAYS collapses after earnings announcements. Event is over, uncertainty resolved, IV drops 30-60% overnight. As certain as gravity.
• Refined approach: Track historical ratio of actual earnings move vs implied expected move. Many stocks consistently move LESS than options imply. For those stocks, selling premium has structural edge.
• Example: AAPL options imply ±5% move, but AAPL moved less than ±5% in 14 of last 16 earnings. Selling the ±5% strangle has ~87% historical win rate.
• Trade structure: Iron condors or iron butterflies (NOT naked strangles). Short strikes at edges of expected move. Sell 1-2 days before earnings. IV crush makes all four legs cheaper after earnings. Buy back for less.
• Win rate: 65-80% (depends on stock selection and strike selection)
• Return: 25-50% per year; 15-40% per trade on risk capital
• Capital: $25K+
• Frequency: 40-80 trades per year across 4 earnings seasons
• Scale to: $1M (larger amounts start impacting options on smaller underlyings)
• Risk: NVDA +25% after earnings blows through strikes. Always defined-risk structures.
• Automation: Highly automatable. Historical earnings move data available, IV calculations standard.
• Models: Opus.

9. Kalshi Economic Data Leading Indicators

• The certainty: Leading indicators (ADP, GDPNow, gas prices, Manheim used car index) bound upcoming economic releases within tight ranges BEFORE official numbers release.
• Example: ADP prints +300K on Wednesday. NFP has never been negative when ADP > +200K. Kalshi prices "NFP positive" at 93%. Buy YES at $0.93, collect $1.00 on Friday.
• Win rate: 95-99%
• Return: 3-10% per trade; 4-8 opportunities per month
• Capital: $2K-$10K
• Scale to: Limited by Kalshi liquidity per market
• Automation: Highly automatable. Scrape ADP/GDPNow/gas prices, compare to Kalshi prices, execute when gap exceeds threshold.
• Models: Opus.

Tier 3: Clever / Niche

10. Liquidation Cascade Recovery (Crypto)

• The certainty: Leverage is finite. When crypto drops fast, forced liquidations push price BELOW fair value. The cascade MUST end because there is a finite amount of leverage in the system. Once exhausted, price recovers 30-60% of the drop within 4-24 hours.
• Signal: Monitor Coinglass + exchange WebSocket. When >$500M cumulative liquidations in 1-4 hours for BTC, AND funding rates go deeply negative, the cascade is likely near exhaustion.
• Trade: Buy spot or go long perps with tight stops below the cascade low.
• Win rate: 70-75%
• Return: 40-80% per year on allocated capital; 3-10% per trade in hours to days
• Frequency: 10-20 major cascades per year
• Capital: $10K+
• Automation: Full. Liquidation data available via APIs, entry/exit rules mechanical.
• Models: Opus.

11. Index Rebalancing Front-Running

• The certainty: When a stock is added to a major index (S&P 500, Russell 2000), index funds MUST buy it on a specific date. They are price-insensitive forced buyers — legal obligation to track the index.
• How: Bot scrapes S&P Dow Jones / FTSE Russell press releases after market close. Buy the stock immediately after announcement. Sell into the rebalance wave on effective date. Hedge with short position in sector ETF to remove market risk.
• Win rate: ~70% (broader market can move against position; hedge mitigates this)
• Return: 15-25% per year on deployed capital
• Capital: $25K+
• Scale to: $50M+ (hedge funds do this but too big for micro-cap additions to smaller indices)
• Automation: NLP/scraper reads press releases and triggers trades. Speed is the edge — first mover wins.
• [PANEL: Gemini 3.1 Pro] Key: sell at the Market-on-Close (MOC) auction on the effective date to catch the guaranteed index fund buying surge.

12. Closed-End Fund Tender Offers

• The certainty: When a CEF announces a tender offer, it MUST buy shares back at 98-100% of NAV. Legal contract. If fund trades at 15% discount, you pocket the gap guaranteed.
• How: Scrape SEC EDGAR for Form TO-I filings. Buy CEF at discounted price. Hedge by shorting underlying assets (muni bond ETF if CEF holds munis, etc.). Submit shares to tender offer.
• Win rate: 90% (risk: oversubscribed offer means they only buy back some of your shares)
• Return: 15-30% per trade on 1-2 month plays
• Capital: $20K+
• Scale to: $5M-$10M (CEF liquidity limits keep large funds out — leaves opportunity for retail)
• Automation: Semi. Bot finds SEC filings and executes buy/hedge. Tender submission typically requires broker API call.
• [PANEL: Gemini 3.1 Pro]

13. Bureaucratic Impossibility (Prediction Markets)

• The certainty: Some events cannot happen by a deadline because the legal/regulatory process takes longer than the remaining time. "Will SEC approve X by May 31?" when the required 21-day comment period has not started and it is May 15 = impossible.
• How: Scan Kalshi/Polymarket for markets where the required procedural steps cannot complete in time. Sell YES / buy NO.
• Win rate: ~98%
• Return: 3-8% per trade
• Capital: $1K+
• Scale to: Limited by prediction market liquidity
• [PANEL: Gemini 3.1 Pro]

14. Callable Bond Convergence

• The certainty: When a bond is called, issuer MUST pay par ($100). If trading at $99.50, buy and collect the guaranteed $0.50.
• How: Screen for bonds near call dates trading below call price (usually par). Account for yield-to-call, fees, and holding period. If net return > hurdle rate, buy.
• Win rate: 90%+ (issuers rarely default exactly at call time)
• Return: 8-15% per year levered; 0.2-0.5% per trade
• Capital: $10K+ muni bonds, $100K+ corporate
• Scale to: $10M+ with broker relationships
• Models: Opus, DeepSeek.

15. Forex Carry Trade with Certainty Filter

• The certainty: Central bank rates are KNOWN and PUBLISHED. The rate differential is mechanical and earns through swap payments every day positions are held. Pegged currencies (HKD, SAR) add a second layer — exchange rate risk is bounded by law.
• How: Identify pairs with rate differential > 3%. ONLY enter when the high-yield currency has recently weakened (buy the dip AND collect carry). Conservative 2-3x leverage maximum. Enter when central bank has signaled no change (windows between meetings where near-term carry is locked in).
• Win rate: 60-70% (currency moves can overwhelm carry)
• Return: 10-25% per year with conservative leverage
• Capital: $10K+
• Scale to: Unlimited (forex $7.5 trillion/day)
• Risk: Carry trade unwind — August 2024 JPY unwind. Conservative leverage is non-negotiable.
• Models: Opus, DeepSeek, Grok.

16. Sports Garbage Time

• The certainty: NBA team up 25+ with 3 minutes left wins 99.98%. Starters pulled. Clock running. But live betting implies only 95-98%.
• How: Monitor live game states. When score_diff and time_remaining cross the threshold, buy winner on Kalshi/Polymarket before the market adjusts.
• Win rate: 99.5-99.9%
• Return: 2-4% edge per bet
• Capital: Minimal
• Catch: Sportsbooks will limit accounts quickly. Kalshi/Polymarket are better venues but have lower liquidity. Stagger accounts and bet sizes.
• Models: Opus, Gemini, DeepSeek.

17. Tennis Tiebreak Rules

• The certainty: In a tiebreak, serve rotation follows specific rules. The original server MUST serve the 3rd point. Live bettors do not know this and markets misprice serve advantages.
• Win rate: ~100% (it is a rule, not a forecast)
• Catch: Very low liquidity on tennis micro-markets.
• [PANEL: DeepSeek V3.1]

18. ETF NAV Discount / Premium

• The certainty: ETFs MUST trade near NAV because authorized participants can create/redeem shares on demand. Discounts are self-correcting mechanisms.
• How:
  • International ETFs (FXI, EWJ) during off-hours: when US sentiment moves these after Asian markets close, buy the dislocation, sell when Asian markets open.
  • Bond ETFs during stress: HYG/LQD at 5%+ discount to NAV (March 2020). Hold until discount closes.
  • CEF reversion (non-tender offer): buy CEFs trading at historically extreme discounts.
• Win rate: 75-85%
• Return: 10-25% per year on CEF reversion; 30-50%+ on crisis dislocations
• Capital: $10K+
• Scale to: $5M CEFs, unlimited for large bond ETFs
• Models: Opus.

19. Liquid Staking Token Depegs

• The certainty: stETH, cbETH, rETH can be redeemed directly for underlying ETH via smart contract. If 1 stETH trades at 0.96 ETH but can be redeemed for 1.0 ETH by waiting 3-15 days, the 4% gap is guaranteed.
• How: Monitor Curve/Uniswap pool prices vs 1.0. When discount > 2%, buy the LST. Initiate redemption via smart contract. Receive underlying ETH in 3-15 days.
• Win rate: 99% (risk = catastrophic smart contract hack)
• Return: 10-40% per year depending on frequency of depegs
• Capital: $5K+
• Scale to: $20M+
• Automation: 100% via Web3.py or Ethers.js for the full lifecycle: DEX purchase through smart contract redemption initiation.
• [PANEL: Gemini 3.1 Pro]

20. Election Night Mail-In Ballot Lag

• The certainty: Mail-in ballots (skew heavily Democratic) are counted last in most states. Early results skew Republican. Markets price in the early results before the demographic correction arrives.
• How: Monitor early results in states with known mail-in patterns. Buy Democratic candidate contracts when early results show GOP leads that will mathematically be erased by uncounted mail-in ballots.
• Win rate: High — this is a well-documented counting sequence
• Catch: Only available during elections. Extremely infrequent.
• Models: DeepSeek, Grok.

21. Corporate Bond Callable Near Call Date

• The certainty: Callable bonds near their call date often misprice due to illiquidity and retail inattention. If the issuer is creditworthy and the bond is at or near call date, convergence to call price (par) is near-certain.
• Win rate: 90%+
• Return: 8-15% annualized
• Capital: $100K+ for corporate, $10K+ for muni
• [PANEL: DeepSeek V3.1]

Prediction Market Execution — Kalshi and Polymarket

Kalshi Ladder Structure

Kalshi uses a CLOB (Central Limit Order Book) with ladder pricing in cents (0-100). Key execution details:

• YES contracts: cost X cents, pay 100 cents on YES resolution
• NO contracts: cost (100-X) cents, pay 100 cents on NO resolution
• Round-trip fee: 7 cents per contract (3.5 each side) on most markets
• Max position: varies by market, typically $25K-$500K per market
• API execution: POST /portfolio/orders with {ticker, action, side, count, type, limit_price}

Fee-adjusted certainty gap threshold for Kalshi:

• Net edge = certainty_score - (market_price_cents / 100) - 0.07
• Only trade when net_edge > 0.03 (3% after fees)

Polymarket Ladder Structure

Polymarket uses a CLOB denominated in USDC (0.00-1.00):

• YES shares: trade at X USDC, pay 1 USDC on YES resolution
• NO shares: trade at (1-X) USDC, pay 1 USDC on NO resolution
• Fee: 2% on each trade (maker 0%, taker 2%)
• Requires wallet with USDC on Polygon network
• API: POST /order to CLOB with {tokenID, price, size, side, type}

Fee-adjusted certainty gap threshold for Polymarket:

• Net edge = certainty_score - market_price - 0.02
• Only trade when net_edge > 0.02 (2% after fees)

Gap Signal Routing Logic

if market_type IN ('kalshi', 'polymarket'):
    min_threshold = 0.05  # 5% net edge minimum for prediction markets
    max_position_usd = 2500  # per market cap
    holding_period = until_resolution or certainty_expires

if market_type IN ('options', 'vix'):
    min_threshold = 0.03  # lower threshold acceptable with high liquidity
    max_position_usd = 10000
    holding_period = 0DTE to 90DTE depending on strategy

if market_type IN ('crypto_funding', 'stablecoin', 'lst'):
    min_threshold = 0.02
    max_position_usd = 5000
    holding_period = hours to weeks

Portfolio Allocation

Recommended baseline allocation for $200K portfolio:

Blended expected annual return: 25-50%

These strategies are largely uncorrelated:

• Options theta runs daily during market hours
• VIX activates only during spikes (3-6x per year)
• Stablecoin activates only during crypto panics
• Funding rate runs 24/7/365
• Earnings runs quarterly
• Liquidation cascade activates during crypto crashes

The meta-strategy: at any given time, multiple strategies generate returns while others sit idle waiting for their certainty gap to appear.

Build Priority

Build in this order — each one teaches you something needed for the next:

1. Crypto Funding Rate Harvest — simplest to implement, runs 24/7, steady returns, teaches exchange API integration and hedge management.
2. Liquidation Cascade Recovery — straightforward signals (Coinglass API), high per-trade returns, teaches real-time WebSocket data handling.
3. Stablecoin Depeg Monitor — set it and forget it. Teaches threshold alerting and tranche execution.
4. 0DTE Theta Decay — highest frequency, most data to learn from quickly. Teaches options chain processing and IV calculations.
5. Earnings IV Crush — seasonal, very backtestable. Teaches historical earnings data pipeline.
6. VIX Mean Reversion — less frequent but high conviction when it triggers. Teaches term structure analysis.
7. Weather Overnight Low Lock-In — copy of existing weather strategy, extend with sunrise logic.
8. Kalshi Economic Leading Indicators — fast to add once weather bot pipeline is running.
9. Index Rebalancing Front-Running [PANEL: Gemini 3.1 Pro] — needs NLP press release scraper. High value per trade.
10. Closed-End Fund Tender Offers [PANEL: Gemini 3.1 Pro] — needs SEC EDGAR scraper. Medium frequency, high win rate.
11. LST (Liquid Staking) Depegs [PANEL: Gemini 3.1 Pro] — needs Web3.py integration. Set and forget.
12. Sports Garbage Time — needs live game state pipeline (already partially built for sports desk).

Key SQL Queries

Find Active Gap Signals Worth Trading

SELECT
    gs.id,
    gs.instrument_label,
    gs.market_type,
    gs.certainty_score,
    gs.market_implied_prob,
    gs.gap_size,
    gs.net_edge,
    gs.recommended_action,
    gs.position_size_kelly,
    gs.max_capital_usd,
    gs.holding_period_est,
    gs.detected_at,
    pl.pattern_name,
    pl.category
FROM gap_signals gs
JOIN pattern_library pl ON gs.pattern_id = pl.id
WHERE gs.signal_status = 'open'
  AND gs.net_edge >= 0.03
  AND gs.resolved_at IS NULL
  AND datetime(gs.detected_at) > datetime('now', '-4 hours')
ORDER BY gs.net_edge DESC;

Pattern Win Rate Summary

SELECT
    pl.pattern_name,
    pl.category,
    pp.total_trades,
    pp.wins,
    pp.losses,
    ROUND(pp.win_rate * 100, 1) AS win_rate_pct,
    ROUND(pp.total_net_pnl, 2) AS total_net_pnl,
    ROUND(pp.avg_return_pct * 100, 2) AS avg_return_pct,
    ROUND(pp.avg_certainty_at_entry * 100, 1) AS avg_certainty_pct,
    ROUND(pp.avg_gap_at_entry * 100, 1) AS avg_gap_pct,
    pp.last_trade_at
FROM pattern_performance pp
JOIN pattern_library pl ON pp.pattern_id = pl.id
WHERE pp.total_trades >= 5
ORDER BY pp.total_net_pnl DESC;

Detect Active VIX Spike (Requires Backfill)

SELECT
    observed_at,
    vix_spot,
    vix_m1,
    vix_m2,
    contango_m1_m2,
    spike_flag,
    reversion_signal
FROM vix_timeseries
WHERE spike_flag = 1
ORDER BY observed_at DESC
LIMIT 20;

Stablecoin Depeg Alert Check

SELECT
    symbol,
    exchange,
    price_usd,
    peg_deviation,
    depeg_alert_level,
    observed_at
FROM stablecoin_prices
WHERE depeg_alert_level != 'none'
  AND datetime(observed_at) > datetime('now', '-30 minutes')
  AND is_algorithmic = 0
ORDER BY peg_deviation ASC;

Find Crypto Funding Rate Opportunities

SELECT
    exchange,
    symbol,
    funding_rate,
    funding_rate_annualized,
    mark_price,
    spot_price,
    basis,
    funding_time
FROM crypto_funding_rates
WHERE is_favorable = 1
  AND datetime(funding_time) > datetime('now', '-2 hours')
ORDER BY funding_rate_annualized DESC
LIMIT 20;

Sports Garbage Time Signal Check

SELECT
    game_id,
    sport,
    home_team,
    away_team,
    score_diff,
    time_remaining_sec,
    win_prob_true,
    win_prob_live_market,
    (win_prob_true - win_prob_live_market) AS gap,
    kalshi_market_id,
    polymarket_id,
    observed_at
FROM sports_live_states
WHERE garbage_time_flag = 1
  AND (win_prob_true - win_prob_live_market) > 0.03
  AND datetime(observed_at) > datetime('now', '-5 minutes')
ORDER BY gap DESC;

Liquidation Cascade Detection

SELECT
    symbol,
    observed_at,
    liq_usd_1h,
    liq_usd_4h,
    long_liq_usd_1h,
    short_liq_usd_1h,
    spot_price,
    funding_rate,
    cascade_signal
FROM crypto_liquidations
WHERE cascade_signal = 1
  AND datetime(observed_at) > datetime('now', '-2 hours')
ORDER BY liq_usd_1h DESC;

Daily Collection Health Check

SELECT
    collector_name,
    COUNT(*) AS runs_today,
    SUM(records_written) AS records_written,
    SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) AS errors,
    MAX(run_at) AS last_run,
    ROUND(AVG(duration_ms)) AS avg_duration_ms
FROM collection_log
WHERE date(run_at) = date('now')
GROUP BY collector_name
ORDER BY collector_name;

Kalshi Markets Matching Pattern Library

SELECT
    km.ticker,
    km.title,
    km.category,
    km.yes_price,
    km.no_price,
    km.volume_24h,
    km.close_time,
    km.pattern_match,
    pl.typical_certainty,
    pl.typical_gap_size,
    (pl.typical_certainty - km.yes_price / 100.0) AS estimated_gap
FROM kalshi_markets km
JOIN pattern_library pl ON km.pattern_match = pl.pattern_name
WHERE km.is_active = 1
  AND km.close_time > datetime('now')
  AND (pl.typical_certainty - km.yes_price / 100.0) > 0.05
ORDER BY estimated_gap DESC;

Trade P&L by Pattern (All Time)

SELECT
    pl.pattern_name,
    pl.category,
    COUNT(t.id) AS trades,
    SUM(t.net_pnl_usd) AS total_pnl,
    AVG(t.return_pct) AS avg_return_pct,
    MIN(t.net_pnl_usd) AS worst_trade,
    MAX(t.net_pnl_usd) AS best_trade,
    SUM(CASE WHEN t.outcome = 'win' THEN 1 ELSE 0 END) AS wins,
    SUM(CASE WHEN t.outcome = 'loss' THEN 1 ELSE 0 END) AS losses
FROM trades t
JOIN pattern_library pl ON t.pattern_id = pl.id
GROUP BY t.pattern_id
ORDER BY total_pnl DESC;

Implementation Checklist

Phase 0: Infrastructure (Do First)

• Create SQLite database at /home/ubuntu/edgeclaw/data/db/certainty-gap.db
• Run all CREATE TABLE statements from schema section
• Create database initialization script (scripts/init-certainty-gap-db.ts)
• Seed pattern_library table with all 21 patterns from this spec
• Create collection_log helper function used by all collectors
• Create gap_signal emitter function used by all scanners
• Set up collection cron schedule in EdgeClaw cron system

Phase 1: Crypto Data Collection (Simplest Feeds First)

• Build crypto funding rate collector (Binance/Bybit WebSocket + REST)
  • Funding rate per symbol every 8h collection
  • Mark price / spot price 1min polling for basis calculation
  • is_favorable flag logic (funding_rate_annualized > 15%)
  • Emit gap_signal when favorable + certainty threshold met
• Build liquidation cascade collector (Coinglass API + Binance WebSocket)
  • Rolling 1h and 4h liquidation aggregation
  • cascade_signal flag logic (>$500M for BTC in 1h)
  • Emit gap_signal on cascade_signal = 1 AND funding_rate < -0.01%
• Build stablecoin price monitor (Coinbase/Binance/Kraken REST)
  • 60-second polling for USDC, USDT, DAI
  • depeg_alert_level calculation
  • Emit gap_signal on any level > 'none' for non-algorithmic stablecoins
• Build crypto futures basis collector (spot vs quarterly futures)
  • Track BTC, ETH quarterly contracts
  • Emit gap_signal when annualized basis > 10%

Phase 2: Prediction Market Feeds

• Build Kalshi market indexer (REST sweep of all market categories)
  • Daily full sweep at 6AM ET to refresh kalshi_markets table
  • 5-minute refresh on flagged markets (pattern_match is not null)
  • Pattern matching logic to link Kalshi markets to pattern_library entries
• Build Polymarket market indexer (REST + CLOB)
  • Daily sweep to refresh polymarket_markets table
  • 5-minute refresh on flagged markets
• Build gap detector for prediction markets
  • Compare certainty_score (from pattern_library.typical_certainty) vs market price
  • Calculate fee-adjusted net_edge
  • Emit gap_signal when net_edge > 0.05

Phase 3: Weather Collection

• Extend existing weather bot to also write to weather_observations table
• Add sunrise/sunset calculation per station
• Add is_post_sunrise and is_post_peak flags
• Add overnight low lock-in scanner (emit gap_signal after sunrise when overnight low confirmed)
• Wire NWS forecast data into certainty score computation

Phase 4: Financial Market Feeds

• Build VIX collector (CBOE delayed quotes + term structure)
  • 5-minute polling during market hours
  • spike_flag and reversion_signal logic
  • Emit gap_signal on reversion_signal = 1 (first down day after spike)
• Build options chain snapshot collector (IBKR or Tradier)
  • Final 3-hour 0DTE option chain pulls for SPX/SPY
  • IV vs realized vol comparison (Variant C)
  • OI clustering detection for pin risk (Variant B)
  • Emit gap_signal when IV > 2x realized vol or pin setup detected
• Build earnings IV history tracker
  • Weekly sweep of upcoming earnings calendar
  • Historical earnings move calculation per ticker (IBKR or Yahoo Finance)
  • Emit gap_signal when historical win rate > 75% for a stock in earnings window
• Build forex rate differential collector (OANDA)
  • Hourly central bank rate fetches
  • rate_differential calculation per pair
  • Forward rate vs spot differential

Phase 5: Equity and Niche Feeds [PANEL Sources]

• Build index rebalancing scraper [PANEL: Gemini 3.1 Pro]
  • S&P Dow Jones press release scraper (daily at 6AM and 6PM ET)
  • FTSE Russell reconstitution page scraper
  • Populate index_rebalancing table on new additions
  • Emit gap_signal on new ADD with effective_date > 5 days out
• Build CEF NAV tracker [PANEL: Gemini 3.1 Pro]
  • Daily NAV pulls from Morningstar or fund sponsors
  • Historical average discount computation
  • SEC EDGAR Form TO-I scraper (daily at 6AM ET)
  • Emit gap_signal on tender offer discovery OR extreme discount (z-score > 2)
• Build LST price monitor [PANEL: Gemini 3.1 Pro]
  • CoinGecko price fetches every 5 minutes for stETH, cbETH, rETH
  • Curve pool price from Ethereum RPC for accuracy
  • Redemption queue days lookup
  • Emit gap_signal when discount > 2% and redemption available
• Build sports live game state collector
  • ESPN live scoreboard + The Odds API live h2h
  • Garbage time flag logic per sport
  • NBA: score_diff >= 25 AND time_remaining_sec <= 180 → flag
  • NFL: score_diff >= 28 AND time_remaining_sec <= 120 AND fourth quarter
  • Emit gap_signal when garbage_time_flag = 1 AND gap > 3%

Phase 6: Gap Detector and Signal Engine

• Build centralized gap detector that reads all data tables
• Implement certainty_score computation functions per pattern type
• Implement market_implied_prob extraction per market type
• Implement fee-adjusted net_edge calculation per venue
• Implement Kelly fraction computation per signal
• Build gap_signals write function with deduplication (don't emit same instrument twice within holding period)
• Build Telegram notification for gap signals above threshold (notify EDGE TEAM group)

Phase 7: Trade Tracking and Performance

• Build trade entry recorder (writes to trades table on execution)
• Build trade exit recorder (updates exit_time, exit_price, P&L on settlement)
• Build pattern_performance update function (runs after each trade closes)
• Build weekly P&L report generator (queries trades, formats for Telegram)
• Build pattern win rate dashboard endpoint

Maintenance

• Daily vacuum on certainty-gap.db (reduce fragmentation)
• Monthly archive of market_snapshots older than 90 days
• Weekly collection health check report (from collection_log queries)
• Nightly pattern_performance recalculation run

Panel Addition: Sonar Reasoning Pro Review (2026-03-16)

Sonar Reasoning Pro reviewed this spec with web-search-augmented analysis. Unique additions below.

[PANEL: Sonar Reasoning Pro] Prediction Market Ladder Exploitation Module

Both Kalshi and Polymarket offer ladder contracts where the same event has multiple threshold contracts (e.g., "Will CPI MoM be 0-0.2%?" / "0.2-0.4%?" / "0.4-0.6%?" etc.). These are mutually exclusive and sum to 100%. The spec must explicitly address how to exploit mispricing across the ladder.

Approach:

1. For each economic data release (CPI, NFP, GDP), build a distribution model using nowcast feeds (Atlanta Fed GDPNow, Bloomberg consensus, ADP data).
2. Integrate the probability density function over each ladder rung to get true probability per contract.
3. Compare model probability to market price for each rung.
4. Execute when gap > threshold (fee + 1% buffer minimum).

Key insight: Tails (extreme outcomes) have the fattest edges because retail doesn't price tail distributions correctly. A certainty gap desk should hunt tail contracts aggressively. Contracts at the center of the distribution are crowded and efficient; move to the edges.

Ladder interaction rule: Since ladder contracts are mutually exclusive and sum to 100%, if you're bullish on a high outcome, you can simultaneously sell the low-end tail and buy the high-end tail for a synthetic directional position.

def exploit_ladder(event, model_distribution, market_prices):
    """
    event: "Will CPI print X-Y%?"
    model_distribution: probability density function from nowcasts
    market_prices: dict of {contract_id: market_price}
    """
    for contract_id, (floor, ceiling) in LADDER_BOUNDS.items():
        true_prob = integrate(model_distribution, floor, ceiling)
        market_prob = market_prices[contract_id]

        edge = true_prob - market_prob
        fee = 0.07 * 100 * market_prob * (1 - market_prob) / (market_prob * 100)

        if edge > fee + 0.01:  # Buy (underpriced)
            position_size = kelly_fraction(edge) * portfolio
            execute_buy(contract_id, position_size)
        elif edge < -(fee + 0.01):  # Sell (overpriced)
            execute_sell(contract_id, abs(position_size))

[PANEL: Sonar Reasoning Pro] Kalshi Fee Calculation — All Strategies

No strategy should execute without factoring in Kalshi's fee formula:

Kalshi taker fee: 0.07 × contracts × price × (1 − price), capped at $1.75 per 100 contracts. Kalshi maker fee: $0.44 per 100 contracts (flat).

Rule for all strategies: Skip any trade where edge < fee + 1% buffer.

Example: CPI tail contract at $0.08, model says $0.10.

• Apparent edge: 25%
• Maker fee impact: 0.07 × 100 × 0.08 × 0.92 / $8.00 = 0.64%
• Net edge: 24.36% — still tradeable.

Example 2: Mid-range contract at $0.50, model says $0.52.

• Apparent edge: 4%
• Fee impact: 0.07 × 100 × 0.50 × 0.50 / $50.00 = 3.5%
• Net edge: 0.5% — SKIP (below 1% buffer).

[PANEL: Sonar Reasoning Pro] Kalshi Interest Income Optimization

Kalshi pays 3.75-4% APY on account balances, accruing daily. The desk should optimize for this:

• Park idle capital in Kalshi earning interest while hunting positions.
• On a $100K account, this is $3,750/year in free alpha the spec previously ignored.
• Factor interest income into the desk's total return calculations.

[PANEL: Sonar Reasoning Pro] Liquidity Check Before Execution

def is_trade_feasible(venue, contract_id, position_size):
    order_book = fetch_order_book(venue, contract_id)
    best_ask = order_book["asks"][0]["price"]
    available_at_ask = sum([ask["size"] for ask in order_book["asks"][:3]])

    # Only trade if liquidity > 1.5x position size
    if available_at_ask < position_size * 1.5:
        return False, f"Insufficient liquidity: {available_at_ask} < {position_size * 1.5}"

    return True, "Trade feasible"

Small position sizes on low-liquidity tail contracts can cause massive slippage. A $5K buy on a $0.05 contract with $10K open interest could push the price to $0.08, destroying the edge.

[PANEL: Sonar Reasoning Pro] Cross-Venue Hedging Logic

If trading Kalshi sports, consider hedging with Polymarket (better political/crypto liquidity) or Pinnacle (sharp sports lines). No strategy should trade in isolation without checking whether a better price exists on another venue.

Venue Selection Rules:

[PANEL: Sonar Reasoning Pro] NWS API Enforcement for Weather

Weather signals MUST use National Weather Service API only (grid-based forecast data). No scraping of forecast.weather.gov — use official NDFD API (NOAA/National Digital Forecast Database). Lock in positions when NWS official forecast diverges >2% from market price. Max lag: 15 minutes from NWS update to order placement.

[PANEL: Sonar Reasoning Pro] Resolution Dispute Risk

Kalshi and Polymarket resolve differently:

• Kalshi: CFTC-regulated, human review, disputes escalated through formal process.
• Polymarket: On-chain resolution via oracles or community vote.

A trade could win on fundamentals but lose on how the market resolves. Add to risk assessment: don't trade if resolution criteria are ambiguous. Flag any contract where resolution rules reference subjective judgment.

End of Certainty Gap Desk — Final Merged Specification