Understanding
Snowden

class Settings(BaseSettings):
    model_config = {"env_prefix": "", "env_file": ".env", "extra": "ignore"}

    # Database
    tsdb_host: str = "localhost"
    tsdb_port: int = 5432
    tsdb_db:   str = "snowden"

    # Polymarket API credentials
    poly_api_key:    str = ""
    poly_api_secret: str = ""
    poly_private_key: str = ""

    # Risk parameters
    max_heat:            float = 0.80   # 80% of equity deployed
    max_single_position: float = 0.25   # 25% max per market
    max_daily_drawdown:  float = 0.10   # 10% triggers kill switch
    max_correlated:      float = 0.40   # 40% per category
    kelly_divisor:       float = 4.0    # quarter-Kelly
    edge_threshold:      float = 0.05   # 5% minimum edge to trade

    @property
    def tsdb_dsn(self) -> str:
        return f"postgresql://{self.tsdb_user}:{self.tsdb_password}@{self.tsdb_host}:{self.tsdb_port}/{self.tsdb_db}"

    @property
    def is_paper(self) -> bool:
        return self.mode == "paper"

settings = Settings()   # module-level singleton

class Regime(StrEnum):
    """Market regime drives strategy selection."""
    CONSENSUS   = "consensus"        # market agrees, little edge
    CONTESTED   = "contested"        # genuine disagreement
    CATALYST    = "catalyst_pending" # event upcoming that will move price
    RESOLVING   = "resolution_imminent"
    STALE       = "stale"            # no one is paying attention
    NEWS_DRIVEN = "news_driven"      # recent news shifted reality

class Strategy(StrEnum):
    THETA          = "theta_harvest"    # near-certain outcomes
    LONGSHOT_FADE  = "longshot_fade"    # overpriced tails
    NEWS_LATENCY   = "news_latency"     # slow price adjustment
    PARTISAN_FADE  = "partisan_fade"    # political bias
    CORRELATED_ARB = "correlated_arb"   # linked market mispricing
    STALE_REPRICE  = "stale_reprice"    # abandoned markets

@runtime_checkable
class MarketClient(Protocol):
    """Swappable backend: LiveClient for real trading, SimClient for paper."""
    async def get_active_markets(self) -> pl.DataFrame: ...
    async def get_book(self, token_id: str) -> dict: ...
    async def get_midpoint(self, token_id: str) -> float: ...
    async def execute(self, signal: TradeSignal) -> OrderResult: ...

def stage_2_liquidity_gate(df: pl.DataFrame) -> pl.DataFrame:
    """Filter markets by minimum liquidity requirements."""
    return df.filter(
        (pl.col("vol_24h") >= settings.min_liquidity_usd)           # >= $5,000
        & ((pl.col("bid_depth") + pl.col("ask_depth"))
           >= settings.min_book_depth_usd)                           # >= $500 total
        & (pl.col("spread") <= settings.max_spread)                 # <= 8%
        & (pl.col("hours_to_resolve") >= settings.min_hours_to_resolve)   # >= 24 hours
        & (pl.col("hours_to_resolve") <= settings.max_days_to_resolve * 24) # <= 180 days
    )

async def stage_5_haiku_triage(
    candidates: list[ScanResult],
    anthropic_client: anthropic.AsyncAnthropic,
) -> list[ScanResult]:
    """Haiku pre-screen: is this worth deep Analyst analysis?"""
    batch_text = "\n".join(
        f"[{i}] Q: {c.market.question} | Mid: {c.market.mid:.2f} | "
        f"Strategies: {', '.join(s.value for s in c.matched_strategies)} | "
        f"Vol24h: ${c.market.vol_24h:,.0f}"
        for i, c in enumerate(candidates)
    )

    response = await anthropic_client.messages.create(
        model=settings.triage_model,   # claude-haiku-4-5
        max_tokens=500,
        system="Select 10-15 markets worth deep analysis. Skip obviously "
               "efficient markets. Respond with comma-separated indices only.",
        messages=[{"role": "user", "content": batch_text}],
    )
    indices = [int(x.strip()) for x in response.content[0].text.split(",")
               if x.strip().isdigit()]
    return [candidates[i] for i in indices if i < len(candidates)]

ANALYST_SYSTEM_PROMPT = (
    "You are a professional prediction market analyst. Estimate the TRUE "
    "probability of an event, independent of the market price.\n\n"

    "CALIBRATION RULES:\n"
    "1. When you say 70%, the event should happen ~70% of the time.\n"
    "2. Base estimates on EVIDENCE, not narrative. Weight hard data\n"
    "   (polls, filings, schedules) over soft signals (sentiment, vibes).\n"
    "3. Political markets: weight polling aggregates over pundit takes.\n"
    "4. Distinguish 'I don't know' (low confidence, near market price)\n"
    "   from 'the market is wrong' (high confidence, far from market).\n"
    "5. Biases to AVOID:\n"
    "   - Anchoring on the current market price\n"
    "   - Narrative bias (good story != high probability)\n"
    "   - Recency bias (last week's news != permanent shift)\n"
    "   - Round number bias (don't cluster at 50%, 75%, 90%)\n"
    "6. If evidence is thin, say so. Set confidence LOW.\n\n"

    "IMPORTANT: p_est_raw is YOUR raw estimate BEFORE calibration.\n"
    "The system applies Platt scaling separately. Give your honest best."
)

async def analyze_market(
    scan: ScanResult, calibrator: Calibrator,
    client: anthropic.AsyncAnthropic | None = None,
) -> EventAnalysis | None:

    # Step 1: Fetch fresh news for this market's category
    news_items = await fetch_news_for_market(
        scan.market.question, scan.market.category.value,
    )
    scan.news_headlines = [item.title for item in news_items]

    # Step 2: Build the analyst prompt
    prompt = build_analyst_prompt(scan)

    # Step 3: Call Opus, parse JSON response
    response = await client.messages.create(
        model=settings.analyst_model,  # claude-opus-4-6
        max_tokens=settings.analyst_max_tokens,
        system=ANALYST_SYSTEM_PROMPT,
        messages=[{"role": "user", "content": prompt}],
    )
    data = json.loads(response.content[0].text.strip()
                      .replace("```json", "").replace("```", ""))

    # Step 4: Apply calibration correction
    raw_est = float(data["p_est_raw"])
    calibrated = calibrator.correct(raw_est)

    return EventAnalysis(
        market_id=data["market_id"], question=data["question"],
        p_market=float(data["p_market"]),
        p_est=calibrated, p_est_raw=raw_est,
        confidence=float(data["confidence"]),
        regime=Regime(data["regime"]),
        edge=round(calibrated - float(data["p_market"]), 4),
        reasoning=data["reasoning"],
        key_factors=data.get("key_factors", []),
        data_quality=float(data.get("data_quality", 0.5)),
        strategy_hint=Strategy(data["strategy_hint"]) if data.get("strategy_hint") else None,
    )

def kelly_fraction(
    p_est: float, p_market: float,
    divisor: float | None = None,
    max_frac: float | None = None,
) -> float | None:
    """Returns None if no edge or negative Kelly."""
    divisor = divisor or settings.kelly_divisor     # 4.0
    max_frac = max_frac or settings.max_single_position # 0.25

    # Minimum edge threshold to avoid noise trades
    if abs(p_est - p_market) < settings.kelly_edge_threshold: # 3%
        return None

    if p_est > p_market:
        b = (1.0 / p_market) - 1.0            # decimal odds
        f = (p_est * b - (1 - p_est)) / b   # Kelly fraction
    else:
        # Buying NO: mirror the probabilities
        p_no_market = 1.0 - p_market
        p_no_est = 1.0 - p_est
        b = (1.0 / p_no_market) - 1.0
        f = (p_no_est * b - p_est) / b

    if f <= 0:
        return None

    return float(np.clip(f / divisor, 0.0, max_frac))

def build_signal(market_id, yes_token, no_token,
                  p_est, p_market, confidence, bankroll, strategy):
    # Confidence-weighted edge must exceed 5%
    edge = abs(p_est - p_market) * confidence
    if edge < settings.edge_threshold:
        return None

    going_yes = p_est > p_market
    size = compute_size(effective_p_est, effective_p_market, bankroll)
    if size is None or size < settings.min_trade_usd:  # $5 minimum
        return None

    return TradeSignal(
        direction="YES" if going_yes else "NO",
        size_usd=round(size, 2),
        limit_price=effective_p_market + settings.slippage_buffer,  # +$0.01
        kelly_frac=size / bankroll,
        edge=round(p_est - p_market, 4),
        ...
    )

def check_signal(
    signal: TradeSignal, portfolio: PortfolioState,
) -> RiskCheck:

    # CHECK 1: Single position size
    single_exposure = signal.size_usd / portfolio.total_equity
    if single_exposure > settings.max_single_position:  # > 25%
        return RiskCheck(approved=False, reason="Single position too large", ...)

    # CHECK 2: Portfolio heat (total capital deployed)
    new_heat = (portfolio.heat * portfolio.total_equity + signal.size_usd) \
               / portfolio.total_equity
    if new_heat > settings.max_heat:  # > 80%
        return RiskCheck(approved=False, reason="Heat limit exceeded", ...)

    # CHECK 3: Daily drawdown (kills switch if > 10%)
    if portfolio.daily_drawdown > settings.max_daily_drawdown:
        return RiskCheck(approved=False, reason="FROZEN: drawdown limit", ...)

    # CHECK 4: Correlated exposure (same category)
    correlated_usd = sum(
        p.size_usd for p in portfolio.positions
        if p.category.value == signal.category.value
    )
    if (correlated_usd + signal.size_usd) / portfolio.total_equity
            > settings.max_correlated:  # > 40%
        return RiskCheck(approved=False, reason="Correlated limit", ...)

    # All checks passed
    return RiskCheck(approved=True, heat=new_heat, ...)

async def execute_signal(
    signal: TradeSignal,
    client: LiveClient | SimClient,
    store: Store,
) -> OrderResult:
    # Pre-execution: check order book hasn't moved against us
    book = await client.get_book(signal.token_id)
    best_ask = float(book["asks"][0]["price"]) if book.get("asks") else 1.0

    # Slippage guard: abort if book moved > 3% against us
    if signal.direction == "YES" and best_ask > signal.p_market * 1.03:
        return OrderResult(status="CANCELLED", ts=datetime.now(UTC))

    # Execute through client (live order or paper fill)
    result = await client.execute(signal)

    # Log every execution to TimescaleDB
    await store.log_trade(signal, result, paper=result.status == "PAPER")
    return result

class Calibrator:
    def __init__(self):
        self._scaler = LogisticRegression(C=1.0, solver="lbfgs")
        self._fitted = False

    async def fit_from_db(self, store: Store, min_samples=50) -> bool:
        resolved = await store.get_resolved_predictions()
        if len(resolved) < min_samples:
            return False  # Not enough data yet

        preds = resolved["p_est_raw"].to_numpy().astype(np.float64)
        actuals = resolved["outcome"].to_numpy().astype(np.int32)

        # Clip to avoid log(0), convert to log-odds
        preds = np.clip(preds, 0.001, 0.999)
        logits = np.log(preds / (1.0 - preds)).reshape(-1, 1)

        self._scaler.fit(logits, actuals)
        self._fitted = True
        return True

    def correct(self, raw_prob: float) -> float:
        """Apply Platt scaling. Pass-through if not yet fitted."""
        if not self._fitted:
            return raw_prob
        raw_prob = float(np.clip(raw_prob, 0.001, 0.999))
        logit = np.log(raw_prob / (1.0 - raw_prob))
        return float(self._scaler.predict_proba([[logit]])[0][1])

CREATE TABLE predictions (
    ts           TIMESTAMPTZ NOT NULL,
    market_id    TEXT        NOT NULL,
    question     TEXT,
    p_market     FLOAT8,
    p_est        FLOAT8,         -- calibrated estimate
    p_est_raw    FLOAT8,         -- raw LLM output
    confidence   FLOAT8,
    regime       TEXT,
    strategy     TEXT,
    edge         FLOAT8,
    reasoning    TEXT,
    data_quality FLOAT8      DEFAULT 0.5,
    resolved     BOOLEAN     DEFAULT FALSE,
    outcome      SMALLINT        -- 1 = YES, 0 = NO
);
SELECT create_hypertable('predictions', 'ts');
CREATE INDEX idx_pred_market ON predictions (market_id, ts DESC);
CREATE INDEX idx_pred_resolved ON predictions (resolved) WHERE resolved = true;

-- Live Brier score, average edge, and confidence over time
CREATE MATERIALIZED VIEW prediction_accuracy_hourly
WITH (timescaledb.continuous) AS
SELECT
    time_bucket('1 hour', ts) AS bucket,
    COUNT(*) AS n_predictions,
    COUNT(*) FILTER (WHERE resolved) AS n_resolved,
    AVG(CASE WHEN resolved THEN (p_est - outcome)^2 END) AS brier_score,
    AVG(edge) AS avg_edge,
    AVG(confidence) AS avg_confidence
FROM predictions GROUP BY bucket;

class SnowdenReplayEnv(gym.Env):
    def __init__(self, predictions: pl.DataFrame, initial_bankroll=2000.0):
        # Obs: [p_est, p_market, edge, confidence, spread, days_to_resolve]
        self.observation_space = spaces.Box(-1, 365, shape=(6,), dtype=np.float32)
        # Action: [skip, small 5%, medium 10%, large 20%]
        self.action_space = spaces.Discrete(4)

    def step(self, action):
        size_map = {0: 0.0, 1: 0.05, 2: 0.10, 3: 0.20}
        bet = size_map[action] * self._bankroll
        # PnL computed from resolved outcome + market price
        self._bankroll += pnl
        self._peak = max(self._peak, self._bankroll)
        return obs, pnl, done, False, {"bankroll": ..., "drawdown": ...}

async def run_cycle(self, cycle_number: int) -> None:
    self._portfolio.cycle_number = cycle_number

    # Reload positions from DB
    positions_df = await self._store.get_active_positions()
    self._portfolio.positions = self._build_positions(positions_df)

    # Kill switch check
    if check_kill_switch(self._portfolio):
        log.critical("FROZEN", reason="kill_switch_active")
        return

    # Scan stages 1-5
    approved, stage_counts, scan_ms = await self._scan()
    await self._store.log_scan_metrics(stage_counts, scan_ms)

    if not approved:
        log.info("no_opportunities"); return

    # Enrich with price history, then analyze with Opus
    analyses = await analyze_batch(approved, self._calibrator)

    # Build signals → Sentinel risk check → Trader execution
    for analysis in analyses:
        if analysis.confidence < settings.min_confidence: continue
        signal = build_signal(
            market_id=analysis.market_id,
            p_est=analysis.p_est, p_market=analysis.p_market,
            confidence=analysis.confidence,
            bankroll=self._portfolio.bankroll,
            ...
        )
        if signal is None: continue

        risk = check_signal(signal, self._portfolio)
        if not risk.approved: continue

        result = await execute_signal(signal, self._client, self._store)
        if result.status in ("FILLED", "PAPER"):
            self._portfolio.bankroll -= signal.size_usd
            self._portfolio.heat = risk.heat

    # Snapshot portfolio state to TimescaleDB
    await self._store.log_portfolio_snapshot(self._portfolio)
    log.info("cycle_complete", cycle=cycle_number,
             bankroll=round(self._portfolio.bankroll, 2))