Fonflo System Architecture

ES futures trading intelligence system. Auto-generated documentation for continuous improvement.

System Overview

Fonflo is an automated ES (E-mini S&P 500) futures signal generation and monitoring system. It runs 24/7 with market-hours task scheduling, integrates multiple external signal sources, applies institutional-grade confidence scoring, and publishes signals and analytics to Discord.

Tech Stack

Task Schedule (PST)

Component Groups

• Always-running: discord_monitor, substack_monitor, email_monitor, x_monitor, news_monitor, welcome_bot
• Market-hours (6 AM - 2 PM PST): regime_detector, session_manager, correlation_filter, internals_monitor, orderflow_engine, price_alerts, alert_engine, quant_signals

Signal Pipeline

Every signal flows through a strict pipeline: Detection → Dedup → Scoring → Validation → Discord → Outcome Tracking.

Signal Detection

Confidence Scoring

Base confidence from signal engine (6 default)

Session adjustment:
  PREMARKET (6-9:30 AM):    base - 1
  OPEN (9:30-11 AM):        base - 2  (choppy)
  MIDMORNING (11-12):       base + 0
  LUNCH (12-1 PM):          base + 1
  AFTERNOON (1-3 PM):       base - 1
  POWERHOUR (3-4 PM):       base - 2  (wild)

Regime adjustment:
  TRENDING:    +0
  RANGING:     +2  (mean reversion setups)
  VOLATILE:    +3  (tight stops)

Confluence bonuses:
  + intel source match:     +2
  + level confluence:       +1
  + internals (tick/trin):  +1
  + correlation (NQ/CL):   +1
  + aplus filter:           +1

Risk penalties:
  - Event lockout:          -2
  - VIX extreme:            -1
  - Counter-trend regime:   -4
  - Inventory extreme:      -2

Final: clipped to 4-9 range
Gate: Only post if confidence >= 8

Deduplication Rules

Edge Detection

Formula: 60% * (sources_aligned / 2) + 40% * (confluence / 5)
Threshold: >= 85% triggers "Fonflo Edge Detection" badge

Sources: intel_1 alignment, intel_2 alignment
Confluence: VIX, major level, price action, time-of-day, volume

Signal 1-3: No Edge Detection required
Signal 4+:  Must pass Edge Detection or suppressed

Morning Report

The largest module (2786 lines). Generates a pre-market narrative report as PNG for Discord at 6:15 AM PST.

Generation Flow

Verification Checks

• HOD/LOD: Validates high-of-day and low-of-day references against real data
• RTH/ETH confusion: Catches mixing of RTH close with overnight prices
• Price accuracy: Compares every mentioned price against actual data
• Narrative tone: Flags "flat" for +2% days, "sold off" for +1% days, etc.
• Level ordering: R3 > R2 > R1 > Pivot > S1 > S2 > S3
• Level staleness: Flags pivot >100pts from current live price
• VIX accuracy: Compares mentioned VIX against actual
• Economic events: Validates event times and names
• Claude deep-check: LLM reviews for subtle logical errors

Draft Approval Workflow

Levels Engine

level_engine.py (994 lines) — Three-tier data sourcing with LLM-based smart money cross-reference.

Prior RTH Data Fallback Chain

1. RTH Snapshot (data/rth_session.json) — captured at 1:55 PM PST. Must match yesterday's date or skipped.
2. yfinance daily bars — clean RTH H/L/C from ES=F ticker
3. yfinance 5m intraday — filter to 9:30 AM - 4:00 PM ET window

Level Calculation

Pivot = (H + L + C) / 3
R1 = 2*Pivot - L    R2 = Pivot + (H-L)    R3 = H + 2*(Pivot-L)
S1 = 2*Pivot - H    S2 = Pivot - (H-L)    S3 = L - 2*(H-L)

Separation: min 8pts between levels (or ATR*0.5)
Rounding: nearest 0.25

Gap Detection: if current price >100pts from pivot,
recalculate using 24hr H/L/C (includes overnight)

Regime Detector

ATR_short = ATR(10 bars)    ATR_long = ATR(30 bars)
MA_fast = SMA(20)           MA_slow = SMA(50)

VOLATILE:      ATR_short/ATR_long >= 1.5 and range_ratio > 1.3
TRENDING_UP:   close > MA_fast > MA_slow and close > VWAP and 3 higher closes
TRENDING_DOWN: close < MA_fast < MA_slow and close < VWAP and 3 lower closes
RANGING:       ATR_ratio <= 0.85
DEFAULT:       VWAP bias + close direction

Intelligence Sources

Three proprietary intelligence feeds. Never mentioned by name in public channels.

Source 1 — Discord Monitor

Source 2 — Substack RSS

Source 3 — Email (Gmail IMAP)

Quant Lab

Autonomous AI-powered strategy discovery engine running 24/7.

Strategy Discovery Pipeline

Grade Criteria

10pt floor rationale: Volatile ES sessions have 50-100pt daily ranges. Sub-10pt edges get eaten by spread, slippage, and intra-bar variance. Strategies must demonstrate they can pull at least 10pts per trade (after costs) to survive. This applies to both in-sample and out-of-sample mean P&L.

Production Tracking

Lab Token Budget

Lab Cost Breakdown

Rules & Guardrails

Signal Rules

Morning Report Rules

Public Channel Rules

Data Rules

File Map

Core Pipeline

Intelligence

Market Context

Quant Lab

State Files (data/)

Data Flow Summary

IBKR TWS ──→ orderflow_engine ──→ signal_queue ──→ alert_engine ──→ Discord
                  │                                      ↑
                  └──→ bar_queue ──→ regime_detector ─────┘
                                          │
Schwab API ──→ price_alerts ─────────────→ alert_engine
    │              │
    └──→ level_engine ──→ levels.json ──→ morning_report
    │                                         │
    └──→ schwab_data ──→ fonflo_graphics     ↓
                              │          PNG → Discord
Discord ──→ discord_monitor ──→ adam_log.json ──→ alert_engine (bonus)
Substack ──→ substack_monitor ──→ mancini_log.json ──→ morning_report
Gmail ──→ email_monitor ──→ tictoc_log.json ──→ morning_report

Claude Haiku ──→ strategy_inventor ──→ strategy_lab ──→ production_tracker
                                                              │
                                                    signal_engine ──→ Discord

Known Issues & Fragile Patterns

Implementation Logic (Pseudocode)

Actual decision logic extracted from source code. Line numbers reference the Python files.

Signal Detection — price_alerts.py _check_signals()

# FREQUENCY GATES (applied before any detection)
IF abs(current_price - last_signal_price) < 15pts:  SKIP    # MIN_PRICE_MOVE
IF (now - last_signal_time) < 15min AND direction flipped:  SKIP  # FLIP_COOLDOWN
IF len(price_history) < 5:  SKIP   # need min samples for rejection detection

# BEARISH at R1/R2 (resistance rejection)
FOR each level in [R1, R2]:
  recent_high = max(price_history[-5:])
  IF recent_high >= level - 8pts          # touched resistance (PROXIMITY_PTS=8)
  AND current_price < level - 15pts       # pulled back (REJECTION_PTS=15)
  AND trend == DOWN:                      # confirmed downtrend

    # Intel filter: skip if any source is explicitly BULLISH
    IF mancini_bias == "BULLISH" OR tictoc_bias == "BULLISH":  SKIP

    # Confluence check: count aligned factors
    confluence = 0
    IF mancini_bias == "BEARISH":  confluence += 1
    IF tictoc_bias == "BEARISH":   confluence += 1
    IF vix > 25:                   confluence += 1
    IF price_action_bearish:       confluence += 1

    # If both sources SILENT: require 2+ non-intel factors
    IF mancini_bias is None AND tictoc_bias is None:
      IF confluence < 2:  SKIP
    IF confluence == 0:  SKIP

    entry = int(current_price)
    stop  = min(level + 8, entry + 20)    # MAX_STOP_PTS = 20
    target = next_lower_level(pivot, S1)

    # R:R validation
    risk = abs(entry - stop)
    reward = abs(entry - target)
    IF reward > 30:  target = entry - 30   # MAX_TARGET_PTS = 30
    rr = reward / risk
    IF rr < 1.2 OR rr > 3.0:  SKIP        # MIN/MAX_RR_RATIO

    FIRE BEARISH signal

# BULLISH at S1/S2/Pivot (support bounce) — mirror logic
FOR each level in [S1, S2, Pivot]:
  recent_low = min(price_history[-5:])
  IF recent_low <= level + 8pts AND current_price > level + 15pts AND trend == UP:
    [same intel/confluence checks, reversed direction]
    entry = int(current_price)
    stop  = max(level - 8, entry - 20)
    target = next_higher_level(pivot, R1)
    FIRE BULLISH signal

# BREAKOUT (R1 break with momentum)
IF current_price > R1 + 8pts
AND recent_low < R1              # was below R1 recently
AND trend == UP
AND (mancini == "BULLISH" OR tictoc == "BULLISH"):  # requires intel confirmation
  entry = current_price
  stop = max(R1 - 5, entry - 20)
  target = R2
  FIRE BULLISH breakout

# BREAKDOWN (S1 break with momentum) — mirror of breakout
IF current_price < S1 - 8pts
AND recent_high > S1 AND trend == DOWN
AND (mancini == "BEARISH" OR tictoc == "BEARISH"):
  FIRE BEARISH breakdown

Validation Gate — price_alerts.py _send_alert()

# HARD VALIDATION (before anything posts to Discord)
IF abs(entry - stop) > 20:  SUPPRESS          # stop too wide
IF reward/risk < 1.2 OR > 3.0:  SUPPRESS      # R:R out of range

# STALE ENTRY CHECK
current_price = schwab.get_es_quote()["last"]
IF direction == LONG:
  overshoot = current_price - entry
  IF overshoot > 10pts:  SUPPRESS              # entry too stale, price ran away
  IF overshoot > 5pts:   RE-PRICE entry to current, adjust stop/target
ELIF direction == SHORT:
  overshoot = entry - current_price
  [same logic reversed]

# EDGE DETECTION GATE (signal #4+)
IF daily_signal_count >= 3:
  confidence = (sources_aligned/2 * 0.6) + (confluence_count/5 * 0.4)
  IF confidence < 0.75:  SUPPRESS              # not enough edge for 4th+ signal

# If all gates pass:
#   1. Generate PNG via fonflo_graphics
#   2. POST to Discord
#   3. Set _active_signal for outcome tracking
#   4. Increment counters

Confidence Scoring — alert_engine.py

# Step-by-step confidence calculation
total = signal.base_confidence    # Tier 1 = 3, Tier 2 = 2

# DELTA STRENGTH
IF delta_strength == "Strong":  total += 2
ELIF delta_strength == "Weak":  total -= 1

# LEVEL CONFLUENCE
IF strong_level within 3.0pts:  total += 2
ELIF weak_level nearby:         total += 1

# LEVEL RECLAIM PRIORITY
IF signal_type == "LEVEL_RECLAIM":
  IF priority <= 2:  total += 2
  ELIF priority <= 4: total += 1

# PIVOT CONFLUENCE
IF price within 5.0 of pivot:  total += 2
  IF LONG AND price >= pivot:  total += 1    # pivot reclaim bonus
  IF SHORT AND price <= pivot: total += 1    # pivot loss bonus

# INTEL AGREEMENT
IF source1_signal matches direction AND not expired (120min):  total += 2
IF source2_level within 5pts of signal:  total += 2 (failed breakdown) or +1 (regular)
IF source3_bias matches direction:  total += 1
IF all three agree:  total += 1  (triple confluence bonus)

# REGIME
IF regime matches signal direction:     total += 1
IF regime OPPOSES signal (counter-trend): total -= 4   # HEAVY PENALTY
IF regime == VOLATILE:                  total -= 1

# CORRELATION (NQ/CL)
total += correlation.confidence_adjustment    # typically -1 to +1

# MULTI-TIMEFRAME
IF signal.timeframe == 5min:  total += 1

# MARKET INTERNALS
total += internals.confidence_for_direction()  # -1 to +2

# SESSION WEIGHTS (time-of-day adjustment)
# Pre-market: threshold +2 | Open: -1 | Midmorning: 0
# Lunch: +3 | Afternoon: -1 | Power hour: -1

# GATE: Only post if total >= ALERT_MIN_CONFIDENCE (8)

Edge Detection Formula — signal_logger.py

# Edge Detection — determines if signal gets "Fonflo Edge Detection" badge
source_weight = 0.6      # 60% weight on source alignment
confluence_weight = 0.4   # 40% weight on confluence factors

source_score = (sources_aligned / 3) * 100 * 0.6
# sources: intel_1, intel_2, level_at_major

confluence_score = (confluence_factors / 5) * 100 * 0.4
# factors: VIX, alert signal, time-of-day, price action, volume

confidence = round(source_score + confluence_score)
EDGE_TRIGGERED = confidence >= 85

# Examples:
# 3/3 sources + 4/5 factors = (1.0 * 60) + (0.8 * 40) = 92% ✓ TRIGGERED
# 2/3 sources + 5/5 factors = (0.67 * 60) + (1.0 * 40) = 80% ✗ NOT TRIGGERED
# 2/3 sources + 4/5 factors = (0.67 * 60) + (0.8 * 40) = 72% ✗ NOT TRIGGERED
# 3/3 sources + 3/5 factors = (1.0 * 60) + (0.6 * 40) = 84% ✗ NOT TRIGGERED

Deduplication Logic — signal_logger.py

PRICE_THRESHOLD = 4.0 pts
TIME_WINDOW = 15 minutes
MAX_SAME_DIRECTION = 2

# HARD CAP: max 2 active signals in same direction
same_dir_active = [s for s in active_signals
                   if s.direction == new.direction
                   and s.status in (PENDING, ACTIVE)]
IF len(same_dir_active) >= 2:  SUPPRESS "MAX_SAME_DIRECTION"

# PROXIMITY CHECK: same area + recent = duplicate
FOR each active signal of same direction:
  price_diff = abs(signal.entry - new_entry)
  time_diff = (now - signal.timestamp).minutes

  IF price_diff <= 4.0 AND time_diff <= 15:
    UNLESS signal.status in (STOPPED_OUT, SCRATCH):
      SUPPRESS "DUPLICATE"

# Cleanup: remove signals older than 8 hours
# Or older than 15min AND status is closed

Regime Classification — regime_detector.py

# Inputs: 1-min bars from IBKR via bar_queue
atr_short = ATR(last 10 bars)     # 10-min momentum
atr_long  = ATR(last 30 bars)     # 30-min structural
atr_ratio = atr_short / atr_long

ma_fast = SMA(last 20 bars)       # 20-min MA
ma_slow = SMA(last 50 bars)       # 50-min MA
vwap = cumsum(price * volume) / cumsum(volume)

range_ratio = avg_range(last 10 bars) / avg_range(prior 10 bars)
higher_closes = bars[-3].close > bars[-4].close > bars[-5].close
lower_closes  = bars[-3].close < bars[-4].close < bars[-5].close

# Classification (checked in order — first match wins)
IF atr_ratio >= 1.5 AND range_ratio > 1.3:
  regime = VOLATILE                # both conditions required

ELIF close > ma_fast > ma_slow AND close > vwap AND higher_closes:
  regime = TRENDING_UP

ELIF close < ma_fast < ma_slow AND close < vwap AND lower_closes:
  regime = TRENDING_DOWN

ELIF atr_ratio <= 0.85:
  regime = RANGING                 # tight compression

ELSE:  # default fallback
  IF close > vwap AND higher_closes:   regime = TRENDING_UP
  ELIF close < vwap AND lower_closes:  regime = TRENDING_DOWN
  ELSE:                                regime = RANGING

# Confidence threshold adjustments
IF VOLATILE:  threshold_delta = +3   # raise thresholds (harder to fire)
IF RANGING:   threshold_delta = +2
ELSE:         threshold_delta = 0

RTH Data Fallback Chain — morning_report.py

# _get_prior_rth_ohlc() — 3-tier fallback for yesterday's RTH H/L/C

# Determine yesterday's trading date
yesterday = (now - 1 day)
WHILE yesterday is weekend:  yesterday -= 1 day
IF yesterday in MARKET_HOLIDAYS:  yesterday -= 1 day (skip holidays too)

# TIER 1: RTH Snapshot (data/rth_session.json)
snapshot = load("data/rth_session.json")
IF snapshot.date == str(yesterday):       # DATE MUST MATCH
  IF snapshot.high > 0 AND snapshot.low > 0:
    RETURN {open, high, low, close from snapshot}
ELSE:
  LOG WARNING "Snapshot STALE — date={snapshot.date}, expected={yesterday}"

# TIER 2: yfinance daily bars (clean RTH H/L/C)
daily = yfinance.Ticker("ES=F").history(period="5d", interval="1d")
IF len(daily) >= 2:
  yesterday_row = daily.iloc[-2]    # second to last (last = today's partial)
  IF high > 0 AND low > 0 AND close > 0:
    RETURN {open, high, low, close from yesterday_row}

# TIER 3: yfinance 5m intraday bars, filtered to RTH window
hist = yfinance.Ticker("ES=F").history(period="2d", interval="5m")
rth_bars = [bar for bar in hist if 9:30 AM ET <= bar.time < 4:00 PM ET
            AND bar.date == yesterday]
IF rth_bars:
  RETURN {open=first.open, high=max(highs), low=min(lows), close=last.close}

RETURN {0, 0, 0, 0}  # all tiers failed

Gap Detection — morning_report.py _get_levels()

# After calculating standard RTH pivots, check if they're relevant

current_price = schwab.get_es_quote()["last"]
pivot = levels["pivot"]

IF abs(current_price - pivot) > 100:    # MASSIVE GAP
  # Standard RTH pivots are useless — recalculate with 24hr data
  gap_h = schwab_quote["high"]     # includes overnight
  gap_l = schwab_quote["low"]      # includes overnight
  gap_c = schwab_quote["close"]    # prior RTH close

  gap_pivot = (gap_h + gap_l + gap_c) / 3
  gap_r1 = 2 * gap_pivot - gap_l
  gap_r2 = gap_pivot + (gap_h - gap_l)
  gap_r3 = gap_h + 2 * (gap_pivot - gap_l)
  gap_s1 = 2 * gap_pivot - gap_h
  gap_s2 = gap_pivot - (gap_h - gap_l)
  gap_s3 = gap_l - 2 * (gap_h - gap_l)

  LOG WARNING "GAP DETECTED: current={current}, RTH pivot={pivot}"
  REPLACE levels with gap-adjusted levels

# Scenario fallbacks also adapt:
IF current_price > R1:
  bull_scenario = "Hold above R1, push through R2. Extended target R3."
  bear_scenario = "Rejection at R2. Fade back to R1 then pivot."
ELIF current_price > pivot + 50:
  bull_scenario = "Hold above pivot. Target R1 then R2."
  bear_scenario = "Lose R1 and fail to hold pivot. Target S1."
ELSE:
  bull_scenario = "Reclaim pivot with volume. Target R1 then R2."
  bear_scenario = "Lose pivot. Target S1 then S2."

Verification Checks — verify_daily_alpha.py

# 9 verification checks run on every morning report draft

CHECK A: HOD/LOD
  Find "high" or "low" near 4-5 digit prices in draft
  IF mentioned_high differs from actual es_high by > 10pts:  ERROR
  IF mentioned_low differs from actual es_low by > 10pts:    ERROR

CHECK B: RTH/ETH Confusion
  IF (current_globex - rth_close) < 10:  SKIP (no confusion possible)
  Find "closed at X" mentions
  IF mentioned_price closer to globex than RTH:  ERROR "RTH/ETH confusion"
  Also flag recovery language ("bounced", "found support") without
  qualifier ("overnight", "globex") when RTH was actually down

CHECK C: Price Accuracy
  Find "closed at X" mentions
  IF abs(mentioned - es_close) > 2pts:  ERROR

CHECK D: Narrative Tone
  Map daily_pct_change to expected descriptors:
    abs(pct) < 0.3%:   "flat" OK
    pct < -0.3%:       "down/sold/declined" expected
    pct > +0.3%:       "up/rallied/gained" expected
  IF flat_word found but abs(pct) >= 0.3%:  ERROR
  IF up_word found but pct < -0.3% (without qualifier):  ERROR
  IF down_word found but pct > +0.3% (without qualifier):  ERROR

CHECK E: Level Ordering
  Extract R3, R2, R1, Pivot, S1, S2, S3 from draft
  Verify strict: R3 > R2 > R1 > Pivot > S1 > S2 > S3
  IF abs(pivot - es_close) > 50pts:  ERROR "unreasonable pivot"
  IF abs(pivot - current_live_price) > 100pts:  ERROR "stale levels"

CHECK F: VIX Accuracy
  Find "VIX at X" mentions
  IF abs(mentioned - vix_actual) > 2:  ERROR

CHECK G: Economic Events
  Extract "EVENT at HH:MM AM/PM ET" from draft
  Match against known calendar
  IF stated_time != expected_time:  ERROR

CHECK H: Claude Deep-Check
  Send draft + market data to Claude API
  Flag ONLY: tone vs reality, wrong close, wrong direction, RTH/ETH confusion
  Do NOT flag: style, opinions, level calculations, approximate language

Smart Setups — realtime_flo.py

# 5 intraday setups, max 3 alerts per session

SETUP 1: IB FADE [BACKTESTED — 64% WR]
  Delegates to quant.signal_engine.check_auction_fade()
  Condition: IB breakout fails, price traps back inside
  Posted as full signal card with entry/stop/target

SETUP 2: FAILED AUCTION [OBSERVATION ONLY]
  FOR each of last 3 bars:
    IF bar.high >= IB_high + 1.0 AND bar.high <= IB_high + 3.0:
      IF any of next 2 bars closes below IB_high:
        Signal: SHORT, stop = bar.high + 2, target = IB_mid
    [Mirror for IB low break → LONG]

SETUP 3: SINGLE PRINTS FILL [OBSERVATION ONLY]
  Track 5-min bars with no overlap to adjacent bars (profile gaps)
  When price returns to fill gap: setup triggered

SETUP 4: EXCESS VOLUME DIVERGENCE [OBSERVATION ONLY]
  New price extremes on declining volume = exhaustion
  Low-volume new highs → bearish divergence
  Low-volume new lows → bullish divergence

SETUP 5: VALUE AREA MIGRATION [OBSERVATION ONLY]
  Developing value area shifts direction mid-session
  Shift UP = bullish continuation, shift DOWN = bearish continuation

POSTING RULES:
  Market hours only (9:30 ET - 4:00 PM ET)
  Min 60 seconds between posts
  Max 3 setup alerts per session
  Backtested → signal card | Non-backtested → observation only
  If no setups by 10:30 ET → post silence message

Backtest Engine — quant/strategy_lab.py

# Walk-forward backtest on 1-min bars

CONSTANTS:
  SLIPPAGE = 0.25 pts per side
  COMMISSION = $4.50 RT = 0.09 pts equivalent
  MIN_SAMPLE_IS = 30 trades (in-sample)
  MIN_SAMPLE_OOS = 20 trades (out-of-sample)

_sim_trade(bars, entry, stop, target, direction):
  FOR each bar after entry:
    IF direction == SHORT:
      IF bar.high >= stop:
        exit = stop + SLIPPAGE
        pnl = entry - exit - COMMISSION_PTS
        RETURN LOSS
      IF bar.low <= target:
        exit = target + SLIPPAGE
        pnl = entry - exit - COMMISSION_PTS
        RETURN WIN

    IF direction == LONG:
      IF bar.low <= stop:
        exit = stop - SLIPPAGE
        pnl = exit - entry - COMMISSION_PTS
        RETURN LOSS
      IF bar.high >= target:
        exit = target - SLIPPAGE
        pnl = exit - entry - COMMISSION_PTS
        RETURN WIN

  # Session ended without hit → exit at last close
  pnl = (last_close - entry) * direction_sign - SLIPPAGE - COMMISSION_PTS
  RETURN WIN if pnl > 0 else LOSS

# WALK-FORWARD SPLIT:
#   Train: months 1-4 (in-sample)
#   Test:  months 5-6 (out-of-sample, strict)
#   Entry: t+1 bar open (zero lookahead)
#   Stops: checked intrabar on H/L, not close

# MONTE CARLO RANDOM CONTROL:
FOR i in 1..200:
  Generate random entries on same trading days
  Use identical stop/target distances
  Compute full P&L distribution
strategy_edge = strategy_mean_pnl / random_mean_pnl

# WILSON SCORE CI (95% on win rate):
z = 1.96
p = win_rate
denom = 1 + z²/n
center = (p + z²/(2n)) / denom
margin = z * sqrt(p(1-p)/n + z²/(4n²)) / denom
ci_lower = max(0, center - margin)
ci_upper = min(1, center + margin)

Strategy Grading — quant/strategy_lab.py

# Grade assignment after backtest + Monte Carlo + VIX decomposition

GRADE A (promote immediately):
  full_profit_factor > 1.5
  AND oos_profit_factor > 1.3
  AND oos_win_rate > 50% (Wilson CI lower bound)
  AND edge_vs_random > 2.0x
  AND n_trades_is >= 30
  AND n_trades_oos >= 20

GRADE B (promote with monitoring):
  full_profit_factor > 1.3
  AND oos_profit_factor > 1.0
  AND oos_win_rate > 45%
  AND edge_vs_random > 1.0x
  AND n_trades_is >= 25
  AND n_trades_oos >= 15

GRADE C (archive, do not promote):
  full_profit_factor > 1.0
  AND (marginal OOS OR thin sample)

GRADE F (killed):
  full_profit_factor <= 1.0
  OR oos_profit_factor < 1.0
  OR oos_win_rate < 45%
  OR fails random test (edge < 1.0x)
  OR n_total < 20

# VIX REGIME DECOMPOSITION:
# Performance split across: VIX < 16 (low), 16-22 (normal), > 22 (elevated)
# Strategy that only works in one regime = conditional bet, not robust edge
# Optimal regime encoded as production filter

Production State Machine — quant/production_tracker.py

# Strategy lifecycle: PROBATION → ACTIVE → DEGRADED → KILLED / DORMANT

track_live_trade(strategy_name, trade):

  # PROBATION PHASE (first 10 trades)
  IF n_trades <= 10:
    IF n_trades >= 5 AND live_pf < 1.0:
      status = KILLED
      reason = "Failed probation: PF < 1.0 after 5 trades"
    IF n_trades == 10:
      status = ACTIVE      # passed probation
      LOG "PROBATION_PASSED"

  # ACTIVE MONITORING
  IF n_trades >= 30 AND live_pf < 0.6:
    status = KILLED
    reason = "Live PF < 0.6 after 30+ trades"

  ELIF n_trades >= 20 AND live_pf < 0.8:
    status = DEGRADED
    reason = "Live PF < 0.8 after 20+ trades"

  ELIF n_trades >= 20 AND (backtest_wr - live_wr) > 0.20:
    status = DEGRADED
    reason = "Live WR dropped 20pp below backtest"

  # RESTORATION
  IF status == DEGRADED AND n_trades >= 20:
    IF live_pf >= 0.8 AND (backtest_wr - live_wr) <= 0.15:
      status = ACTIVE      # restored from degradation

  # DORMANCY
  IF days_since_last_signal >= 15 AND status == ACTIVE:
    status = DORMANT
    reason = "No signals in 15+ trading days"

# State diagram:
#   [NEW] → PROBATION(10 trades) → ACTIVE
#                    ↓ (PF<1.0 @ 5)     ↓ (PF<0.6 @ 30)
#                  KILLED              KILLED
#                                        ↑
#   ACTIVE → DEGRADED (PF<0.8 @ 20) → KILLED (if persists)
#      ↓         ↓ (PF recovers)
#   DORMANT    ACTIVE (restored)

All Configuration Thresholds

Signal Quality

Orderflow

Deduplication

Confidence Adjustments

Session Weights

Market Internals

Backtest

Production Tracker

Last updated: — Auto-generated from codebase audit