Grok × Polymarket 4-Step Multi-Agent Trading Desk: SCAN · VERIFY · EXECUTE · EXIT Pipeline That Filters Out 90% of Bad Trades

# ==============================================================================
# poly_grok_desk.py — 4-Agent Quantitative Trading Desk (SCAN·VERIFY·EXECUTE·EXIT)
# Philosophy: "The best agent on a trading desk has never placed a trade.
#              Its whole job is to say NO."
# Safe Setup (Never echo API keys into terminal history):
#   mkdir -p /workspace/desk && cd /workspace/desk
#   read -rs -p "xai key: " K && printf 'XAI_API_KEY=%s\n' "$K" > .env && unset K
#   chmod 600 .env
# ==============================================================================
import csv, json, os, time
from collections import Counter

# 1. CONFIG (You edit this file. The bot NEVER edits config constants itself.)
MODEL = "grok-4.7"
PAPER = True                  # Paper mode first: real orderbooks, real prices, simulated fills
START_BALANCE = 1000.0        # Dedicated sub-wallet bankroll ($1,000 USDC)
SCANNERS = ["SCAN-1", "SCAN-2", "SCAN-3", "SCAN-4"]
LEADS_PER_RUN = 12            # Cap per 5-min run so a busy minute never burns API budget

SKIP_IF = {
    "min_liquidity_usd": 50_000,   # Pool liquidity < $50k -> instant free SKIP
    "max_spread_cents": 2.2,       # Bid-Ask spread > 2.2¢ -> instant free SKIP
    "min_age_min": 30,             # Market too fresh / unindexed -> SKIP
    "max_hours_to_resolve": 168,   # Capital efficiency: skip dead-money > 7 days out
    "max_ticket_share": 0.01,      # Your order size is NEVER > 1% of orderbook liquidity
}
MIN_X_CONFIDENCE = 0.72       # Grok x_search confidence below 0.72 -> SKIP

SIZE_PCT = 0.15               # Bet 15% of current available cash (capped at $200 & 1% of pool)
MIN_TICKET, MAX_TICKET = 20.0, 200.0
MAX_OPEN = 5                  # Max 5 concurrent slots (5 × $200 = $1,000)
SESSION_LOSS_HALT_PCT = 15.0  # Circuit breaker: down 15% from session start -> halt new entries

EXIT = {
    "hard_stop_pct": -18.0,                  # Price drops 18% -> exit 100% immediately
    "ladder": [(15.0, 0.50), (35.0, 0.50)],  # Take profit ladder: +15% sells half, +35% sells rest
    "trail_pct": 12.0,                       # After first take: exit if price pulls back 12% from peak
    "time_stop_min": 720,                    # 12h flat (< +2%) -> free the slot ("Dead money is a loss")
    "time_stop_min_pct": 2.0,
    "liq_drop_pct": 40.0,                    # Orderbook depth drops 40% since entry -> exit 100% now
}

# 2. VERIFY STEP: Free Deterministic Code Checks FIRST, Paid Grok X-Read LAST
X_READ_PROMPT = """
You are VERIFY, the final gatekeeper on a Polymarket quantitative desk.
This market already passed all hard code checks (liquidity >= $50k, tight spread, valid window).
Search X (Twitter) for the event and audit the UMA Resolution Rules. Judge ONLY what code cannot see:
  1. Ambiguous / subjective UMA resolution criteria (wordplay risk or disputed oracle source)
  2. Coordinated bot hype on X (dozens of fresh accounts posting identical fake breaking news)
  3. Whether the official primary source (Fed / AP / League scoreboard) has actually confirmed
RETURN ONLY JSON: {"verdict": "GO" | "SKIP", "confidence": 0.0-1.0, "why": "one concise line"}
Unsure is SKIP. Anything not valid JSON is SKIP.
"""

def hard_skip(f: dict) -> str | None:
    """Facts are code. A missing field is ALWAYS a skip, never a guess."""
    req = ["price", "liq_usd", "spread_cents", "age_min", "hours_to_resolve", "uma_disputed"]
    if any(f.get(k) is None for k in req):                        return "missing_data"
    if f["uma_disputed"]:                                         return "uma_dispute_active"
    if f["liq_usd"] < SKIP_IF["min_liquidity_usd"]:               return "thin_liquidity"
    if f["spread_cents"] > SKIP_IF["max_spread_cents"]:           return "wide_spread"
    if f["age_min"] < SKIP_IF["min_age_min"]:                     return "too_fresh"
    if f["hours_to_resolve"] > SKIP_IF["max_hours_to_resolve"]:   return "dead_money_horizon"
    return None

def size_order(cash_usdc: float, liq_usd: float) -> float:
    """Sized off the balance you have NOW + capped at 1% of pool depth."""
    usd = cash_usdc * SIZE_PCT
    usd = min(max(usd, MIN_TICKET), MAX_TICKET, liq_usd * SKIP_IF["max_ticket_share"])
    return round(usd, 2)

# 3. EXIT STEP: Written BEFORE Entry (Runs every 5 minutes on all open positions)
def evaluate_exit(pos: dict, cur_price: float, cur_liq: float, now_ts: float) -> tuple[float, str] | None:
    if cur_price <= 0:
        return (1.0, "market_halted")
    peak = max(pos["peak"], cur_price)
    pct = (cur_price / pos["entry"] - 1.0) * 100.0
    age_min = (now_ts - pos["opened_ts"]) / 60.0
    if cur_liq < pos["liq0"] * (1.0 - EXIT["liq_drop_pct"] / 100.0):
        return (1.0, "liquidity_pulled_40pct")
    if pct <= EXIT["hard_stop_pct"]:
        return (1.0, "hard_stop")
    if pos["steps"] < len(EXIT["ladder"]):
        target_pct, frac = EXIT["ladder"][pos["steps"]]
        if pct >= target_pct:
            return (frac, f"take_profit_+{target_pct:.0f}pct")
    if pos["steps"] > 0 and cur_price <= peak * (1.0 - EXIT["trail_pct"] / 100.0):
        return (1.0, "trailing_stop_from_peak")
    if pos["steps"] == 0 and age_min >= EXIT["time_stop_min"] and pct < EXIT["time_stop_min_pct"]:
        return (1.0, "time_stop_dead_money")
    return None

if __name__ == "__main__":
    sample_lead = {"slug": "fed-cuts-25bps-nov", "price": 0.984, "liq_usd": 420_000,
                   "spread_cents": 0.4, "age_min": 1440, "hours_to_resolve": 18, "uma_disputed": False}
    skip_reason = hard_skip(sample_lead)
    ticket_usdc = size_order(1000.0, sample_lead["liq_usd"]) if not skip_reason else 0.0
    print(f"[VERIFY] hard_skip={skip_reason} -> Survivor sent to Grok X-Read | Ticket=${ticket_usdc} USDC")