feat(winrate): add MQ gate, confirmation store, exit safety and tests

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: VirilePeak

scripts/aggregate_trades.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import glob, json
+from pathlib import Path
+
+def main():
+    base = Path("c:/Users/sefa1/agents")
+    pattern1 = str(base / "paper_trades_legacy*.jsonl")
+    pattern2 = str(base / "paper_trades_legacy.jsonl")
+    files = glob.glob(pattern1) + glob.glob(pattern2)
+    latest = {}
+    for fp in files:
+        try:
+            with open(fp, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        j = json.loads(line)
+                    except Exception:
+                        continue
+                    tid = j.get("trade_id")
+                    if not tid:
+                        continue
+                    latest[tid] = j
+        except Exception:
+            continue
+    # include current file
+    cur = base / "paper_trades.jsonl"
+    if cur.exists():
+        with cur.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    j = json.loads(line)
+                except Exception:
+                    continue
+                tid = j.get("trade_id")
+                if not tid:
+                    continue
+                latest[tid] = j
+
+    total = len(latest)
+    open_count = sum(1 for r in latest.values() if r.get("status") != "closed")
+    closed = [r for r in latest.values() if r.get("status") == "closed"]
+    closed_count = len(closed)
+    wins = sum(1 for r in closed if r.get("realized_pnl") is not None and float(r.get("realized_pnl")) > 0)
+    losses = sum(1 for r in closed if r.get("realized_pnl") is not None and float(r.get("realized_pnl")) < 0)
+    ties = sum(1 for r in closed if r.get("realized_pnl") is None)
+    win_rate = (wins / closed_count * 100) if closed_count > 0 else 0.0
+
+    print(f"total:{total} open:{open_count} closed:{closed_count} wins:{wins} losses:{losses} ties:{ties} win_rate:{win_rate:.1f}%")
+
+if __name__ == "__main__":
+    main()
+

src/config/settings.py

@@ -74,6 +74,28 @@ class Settings:
     PREFIX: str = "btc-updown-15m"
     PAPER_LOG_PATH: str = "paper_trades.jsonl"
     GAMMA_API: str = "https://gamma-api.polymarket.com"
+    
+    # Win-rate upgrade (feature flag)
+    WINRATE_UPGRADE_ENABLED: bool = False  # safe default: disabled
+
+    # Market Quality (entry) params
+    MAX_SPREAD_ENTRY: float = 0.10
+    MIN_ASK_SIZE: float = 5.0
+    ENFORCE_DEPTH: bool = True  # if True, require ask size available
+
+    # Entry window
+    ENTRY_WINDOW_END_SECONDS: int = 300  # 5 minutes
+    ENTRY_WINDOW_STRICT: bool = True
+
+    # Confirmation / debounce
+    REQUIRE_CONFIRMATION: bool = True
+    CONFIRMATION_DELAY_SECONDS: int = 60
+    CONFIRMATION_TTL_SECONDS: int = 180
+    PENDING_CONFIRM_PATH: str = "pending_confirmations.json"
+
+    # Exit safety
+    MAX_SPREAD_EXIT: float = 0.15
+    MAX_HOLD_SECONDS: int = 900  # 15 minutes
 
 
 _settings: Optional[Settings] = None

src/utils/winrate_upgrade.py

@@ -0,0 +1,132 @@
+import json
+import os
+import time
+from threading import Lock
+from typing import Any, Dict, Optional, Tuple
+
+
+class ConfirmationStore:
+    def __init__(self, path: str):
+        self.path = path
+        self.lock = Lock()
+        self._data: Dict[str, Dict[str, Any]] = {}
+        self._load()
+
+    def _load(self):
+        try:
+            if os.path.exists(self.path):
+                with open(self.path, "r", encoding="utf-8") as f:
+                    self._data = json.load(f)
+        except Exception:
+            self._data = {}
+
+    def _save(self):
+        tmp = f"{self.path}.tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(self._data, f)
+        os.replace(tmp, self.path)
+
+    def mark_pending(self, key: str, payload: Dict[str, Any]) -> None:
+        with self.lock:
+            self._data[key] = {"first_seen": time.time(), "payload": payload}
+            try:
+                self._save()
+            except Exception:
+                pass
+
+    def pop_if_confirmed(self, key: str, delay: int, ttl: int) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        Returns (confirmed, payload). If confirmed is True, pending entry is removed.
+        """
+        with self.lock:
+            entry = self._data.get(key)
+            if not entry:
+                return False, None
+            now = time.time()
+            first = entry.get("first_seen", now)
+            if now - first > ttl:
+                # expired
+                del self._data[key]
+                try:
+                    self._save()
+                except Exception:
+                    pass
+                return False, None
+            if now - first >= delay:
+                payload = entry.get("payload")
+                del self._data[key]
+                try:
+                    self._save()
+                except Exception:
+                    pass
+                return True, payload
+            return False, None
+
+    def expire_all_older_than(self, ttl: int) -> int:
+        removed = 0
+        now = time.time()
+        with self.lock:
+            keys = list(self._data.keys())
+            for k in keys:
+                if now - self._data[k].get("first_seen", now) > ttl:
+                    del self._data[k]
+                    removed += 1
+            if removed:
+                try:
+                    self._save()
+                except Exception:
+                    pass
+        return removed
+
+
+def check_market_quality_for_entry(best_bid: Optional[float], best_ask: Optional[float], ask_size: Optional[float], settings) -> Tuple[bool, str, Dict[str, Any]]:
+    """
+    Return (ok, reason, details)
+    """
+    details = {
+        "best_bid": best_bid,
+        "best_ask": best_ask,
+        "ask_size": ask_size,
+    }
+    if best_ask is None:
+        return False, "no_entry_price", details
+    if best_bid is None:
+        return False, "no_best_bid", details
+    spread = best_ask - best_bid
+    details["spread"] = spread
+    if spread > settings.MAX_SPREAD_ENTRY:
+        return False, "spread_too_wide", details
+    if settings.ENFORCE_DEPTH:
+        if ask_size is None:
+            return False, "ask_size_unavailable", details
+        try:
+            if float(ask_size) < float(settings.MIN_ASK_SIZE):
+                return False, "ask_size_too_small", details
+        except Exception:
+            return False, "ask_size_unavailable", details
+    return True, "ok", details
+
+
+def compute_time_to_market_end(market: Optional[Dict[str, Any]]) -> Tuple[Optional[int], str]:
+    """
+    Returns (seconds_to_end or None, reason)
+    """
+    if not market:
+        return None, "end_time_unavailable"
+    end_ts = market.get("end_time") or market.get("close_time") or market.get("end")
+    if not end_ts:
+        return None, "end_time_unavailable"
+    try:
+        # Expect ISO format; if numeric epoch, handle
+        from datetime import datetime, timezone
+
+        if isinstance(end_ts, (int, float)):
+            end = datetime.fromtimestamp(float(end_ts), tz=timezone.utc)
+        else:
+            end = datetime.fromisoformat(str(end_ts).replace("Z", "+00:00"))
+        now = datetime.now(timezone.utc)
+        seconds = int((end - now).total_seconds())
+        return seconds, "ok"
+    except Exception:
+        return None, "end_time_unavailable"
+

tests/test_winrate_upgrade.py

@@ -0,0 +1,30 @@
+import os
+import time
+from src.utils.winrate_upgrade import check_market_quality_for_entry, ConfirmationStore
+
+
+def test_check_mq_no_ask():
+    class S: pass
+    settings = type("S", (), {"MAX_SPREAD_ENTRY": 0.1, "MIN_ASK_SIZE": 5.0, "ENFORCE_DEPTH": True})()
+    ok, reason, details = check_market_quality_for_entry(None, None, None, settings)
+    assert not ok and reason == "no_entry_price"
+
+
+def test_check_mq_spread_too_wide():
+    settings = type("S", (), {"MAX_SPREAD_ENTRY": 0.1, "MIN_ASK_SIZE": 5.0, "ENFORCE_DEPTH": False})()
+    ok, reason, details = check_market_quality_for_entry(0.5, 0.7, 10.0, settings)
+    assert not ok and reason == "spread_too_wide"
+
+
+def test_confirmation_store_delay_and_ttl(tmp_path):
+    p = tmp_path / "pending.json"
+    store = ConfirmationStore(str(p))
+    key = "mkt|BULL|sig1"
+    store.mark_pending(key, {"foo": "bar"})
+    confirmed, _ = store.pop_if_confirmed(key, delay=1, ttl=5)
+    assert not confirmed
+    time.sleep(1.1)
+    confirmed, payload = store.pop_if_confirmed(key, delay=1, ttl=5)
+    assert confirmed
+    assert payload is not None
+