┌───────────────────────────────────────────────────────────┐
│                    POLYMARKET ORACLE                       │
│                                                            │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐            │
│  │ 1. DATA   │    │ 2. NEWS   │    │ 3. SIGNAL │           │
│  │ COLLECTOR │    │ SCANNER   │    │ ENGINE    │           │
│  │           │    │           │    │           │           │
│  │ Every     │    │ Every     │    │ Every     │           │
│  │ 15 min    │    │ 30 min    │    │ hour      │           │
│  │           │    │           │    │           │           │
│  │ Polymarket│    │ Reuters   │    │ Stage 1:  │           │
│  │ API →     │    │ Dawn      │    │ Gemini    │           │
│  │ SQLite    │    │ Twitter   │    │ Flash     │           │
│  │           │    │ → SQLite  │    │           │           │
│  │ Markets,  │    │           │    │ Stage 2:  │           │
│  │ prices,   │    │ Headlines,│    │ Claude    │           │
│  │ volumes   │    │ sentiment │    │ Haiku     │           │
│  │           │    │           │    │           │           │
│  └─────┬─────┘    └─────┬─────┘    │ Stage 3:  │           │
│        │                │          │ Claude    │           │
│        └────────────────┴──────────┤ Sonnet    │           │
│                                    └─────┬─────┘           │
│                                          │                  │
│  ┌──────────┐    ┌──────────┐    ┌──────┴─────┐           │
│  │ 6. MONITOR│    │ 5. EXEC   │    │ 4. STRATEGY│           │
│  │           │    │           │    │  ROUTER    │           │
│  │ P&L track │    │ Polymarket│    │            │           │
│  │ Telegram  │    │ CLOB API  │    │ Theta      │           │
│  │ alerts    │    │ Limit     │    │ Sniper     │           │
│  │ Daily     │    │ orders    │    │    OR      │           │
│  │ summary   │    │           │    │ Geo Scout  │           │
│  │           │    │           │    │            │           │
│  └──────────┘    └──────────┘    └────────────┘           │
│                                                            │
└───────────────────────────────────────────────────────────┘

# main.py — Bot orchestrator
import asyncio
import schedule
import signal
import sys
from datetime import datetime
from components.data_collector import DataCollector
from components.news_scanner import NewsScanner
from components.signal_engine import SignalEngine
from components.strategy_router import StrategyRouter
from components.executor import Executor
from components.monitor import Monitor
from config import Config

class PolymarketOracle:
    def __init__(self):
        self.config = Config.load("config.yaml")
        self.collector = DataCollector(self.config)
        self.scanner = NewsScanner(self.config)
        self.engine = SignalEngine(self.config)
        self.router = StrategyRouter(self.config)
        self.executor = Executor(self.config)
        self.monitor = Monitor(self.config)
        self.running = True

    async def run_pipeline(self):
        """Full pipeline: collect → scan → signal → route → execute → monitor."""
        try:
            # Step 1: Fetch latest market data
            markets = await self.collector.fetch_active_markets()
            print(f"[{datetime.now()}] Tracking {len(markets)} markets")

            # Step 2: Scan news for relevant headlines
            articles = await self.scanner.fetch_and_filter()
            print(f"[SCAN] {len(articles)} relevant articles found")

            # Step 3: Generate trading signals
            signals = await self.engine.generate_signals(markets, articles)
            print(f"[SIGNAL] {len(signals)} actionable signals")

            # Step 4: Route signals to strategies
            for signal in signals:
                strategy = self.router.select_strategy(signal)
                trade = strategy.evaluate(signal)

                if trade and trade["action"] != "SKIP":
                    # Step 5: Execute trade
                    if self.config.mode == "live":
                        result = await self.executor.place_order(trade)
                    else:
                        result = self.executor.paper_trade(trade)

                    # Step 6: Log and alert
                    self.monitor.log_trade(trade, result)
                    if trade["action"] == "BUY":
                        await self.monitor.send_alert(
                            f"🟢 BUY {trade['market_id']}\n"
                            f"Price: ${trade['price']}\n"
                            f"Size: ${trade['size']}\n"
                            f"Strategy: {trade['strategy']}\n"
                            f"Confidence: {trade['confidence']:.0%}"
                        )

        except Exception as e:
            await self.monitor.send_alert(f"🔴 PIPELINE ERROR: {str(e)}")
            print(f"[ERROR] Pipeline failed: {e}")

    async def run_daily_report(self):
        """Generate and send daily P&L report."""
        report = self.monitor.generate_daily_report()
        await self.monitor.send_alert(report)

    def start(self):
        """Start the bot with scheduled tasks."""
        print("=" * 50)
        print("  POLYMARKET ORACLE — Starting...")
        print(f"  Mode: {self.config.mode}")
        print(f"  Max position: ${self.config.max_position}")
        print(f"  Daily loss limit: ${self.config.max_daily_loss}")
        print("=" * 50)

        # Schedule tasks
        schedule.every(15).minutes.do(
            lambda: asyncio.run(self.run_pipeline())
        )
        schedule.every().day.at("23:00").do(
            lambda: asyncio.run(self.run_daily_report())
        )

        # Graceful shutdown
        signal.signal(signal.SIGINT, lambda s, f: self._shutdown())
        signal.signal(signal.SIGTERM, lambda s, f: self._shutdown())

        while self.running:
            schedule.run_pending()
            asyncio.get_event_loop().run_until_complete(asyncio.sleep(30))

    def _shutdown(self):
        print("\n[SHUTDOWN] Graceful shutdown initiated...")
        self.running = False
        self.monitor.generate_daily_report()
        sys.exit(0)

if __name__ == "__main__":
    oracle = PolymarketOracle()
    oracle.start()

# config.yaml
mode: paper  # "paper" or "live"

# Risk management
max_position: 50        # Max $ per trade
max_daily_loss: 25      # Stop trading if daily loss exceeds
max_portfolio: 200      # Max total exposure across all positions
max_trades_per_day: 20  # Circuit breaker

# Market selection
min_volume: 50000       # Only trade markets with $50K+ volume
min_edge: 0.10          # Minimum probability edge (10%)
min_confidence: 0.65    # Minimum AI confidence score
price_range: [0.15, 0.85]  # Avoid extreme prices

# AI configuration
gemini_key: ${GEMINI_API_KEY}
claude_key: ${ANTHROPIC_API_KEY}
signal_model: "claude-sonnet-4-6"
filter_model: "gemini-2.5-flash"

# News sources
news_sources:
  - name: reuters
    url: "https://feeds.reuters.com/reuters/worldNews"
  - name: dawn
    url: "https://www.dawn.com/feeds/home"
  - name: business_recorder
    url: "https://www.brecorder.com/feeds"

# Notifications
telegram_bot_token: ${TELEGRAM_BOT_TOKEN}
telegram_chat_id: ${TELEGRAM_CHAT_ID}

# Database
db_path: "oracle.db"

DAY 1: LAUNCH
├── Deploy to VPS with PM2 (auto-restart on crash)
├── Start with Theta Sniper ONLY (safest strategy)
├── Max position: $10 per trade (minimum viable bet)
├── Monitor EVERY trade via Telegram — don't trust blindly
├── Check: Are signals firing? Are orders executing? Is P&L tracking?
└── End of day: Review all trades. Any errors? Any missed signals?

DAY 2-3: VALIDATE
├── If Theta Sniper win rate > 55%: Continue
├── If win rate < 50%: Check signal calibration
│   ├── Are you entering too early? (Increase min_confidence to 0.75)
│   ├── Are you entering too late? (Decrease pipeline interval to 10 min)
│   └── Is the AI miscalibrated? (Review reasoning in signal logs)
├── Compare paper trading results vs. live results
└── Any slippage? Check limit order pricing strategy

DAY 4-5: ADD STRATEGY
├── Enable Geo Scout alongside Theta Sniper
├── Still at $10 max per trade
├── Two strategies diversify across different market types
├── Check: Do the strategies ever conflict? (Both say buy on same market)
└── If conflict: Theta Sniper takes priority (more conservative)

DAY 6-7: WEEKLY REVIEW
├── Total trades executed
├── Win rate per strategy
├── Average profit per winning trade
├── Average loss per losing trade
├── Max drawdown (largest peak-to-trough decline)
├── Total P&L for the week
│
├── IF POSITIVE: Continue to Week 2 (scale phase)
└── IF NEGATIVE: Go back to paper trading, debug signal engine

WEEK 1:   $10/trade  (validation)
WEEK 2:   $10/trade  (confirmation)
WEEK 3:   $25/trade  (first scale)
WEEK 4:   $25/trade  (confirmation)
MONTH 2:  $50/trade  (if consistently profitable)
MONTH 3:  $100/trade (if 60%+ win rate sustained)

NEVER:
├── Risk more than 5% of bankroll on single trade
├── Scale up after a losing week (scale ONLY after winning weeks)
├── Increase both position size AND number of trades simultaneously
└── Go from $10 to $100 in one jump (gradual scaling catches errors)

BANKROLL MANAGEMENT:
Starting bankroll: $200 (PKR 56,000)
├── Week 1-2: $10 max × 20 trades = $200 max exposure (100%)
├── If profitable: Add $200 more (bankroll = $400 + profits)
├── Month 2: $50 max × 10 positions = $500 max exposure
└── Month 3+: Scale based on Sharpe ratio, not feelings

MONTHLY OPERATING COSTS:

VPS (DigitalOcean $5 or Contabo):       PKR 1,400
Gemini API (Flash filter):               Free tier
Claude API (Haiku + Sonnet):             PKR 2,800 (~$10)
Telegram Bot:                             Free
Domain (optional):                        PKR 200
────────────────────────────────────────────────────
TOTAL INFRASTRUCTURE:                     PKR 4,400/month

TRADING CAPITAL:
Starting bankroll:                        PKR 56,000 ($200)
Monthly top-up (if scaling):              PKR 28,000 ($100)

FUNDING PATH:
PKR → Binance P2P → USDC → Polygon → Polymarket
Fee: ~1-2% total (P2P spread + network fee)

BREAK-EVEN ANALYSIS:
Monthly cost: PKR 4,400
At $10/trade, need ~3 profitable trades/month to cover costs
At 60% win rate, 20 trades/month → 12 wins
Average win: $3-5 per trade → $36-60/month profit
After costs: $26-50/month = PKR 7,300-14,000

Month 3+ at $50/trade:
Average win: $15-25 → $180-300/month
After costs: $164-284/month = PKR 46,000-80,000/month